diff --git a/apps/admin-web/src/i18n/messages/en-US.ts b/apps/admin-web/src/i18n/messages/en-US.ts
index 0e92fe6..5c9223f 100644
--- a/apps/admin-web/src/i18n/messages/en-US.ts
+++ b/apps/admin-web/src/i18n/messages/en-US.ts
@@ -81,6 +81,7 @@ const enUS = {
     brandManagement: 'Brand Management',
     tracking: 'Tracking',
     trackingDetail: 'Data Details',
+    trackingMarkedArticles: 'External Article Marks',
     contentManagement: 'Content Management',
     knowledge: 'Knowledge Base',
     images: 'Image Management',
@@ -264,6 +265,11 @@ const enUS = {
       description:
         'Inspect plugin-sampled brand performance, platform coverage, hot questions, and citation attribution.',
     },
+    trackingMarkedArticles: {
+      title: 'External Article Marks',
+      description:
+        'Manage manually marked external article URLs so they count in cited articles and citation rankings.',
+    },
     trackingQuestion: {
       title: 'Question Detail',
       description:
@@ -579,7 +585,7 @@ const enUS = {
     citationRanking: 'Citation Ranking',
     citationRankingTitle: 'Citation Ranking',
     citationRankingHint:
-      'Attribute SaaS-published content by published-link identity across model citation sources.',
+      'Attribute external articles by published links and manually marked URLs across model citation sources.',
     citationWindow7: 'Last 7 days',
     citationWindow30: 'Last 30 days',
     citationWindowLabel: 'Last {days} days',
@@ -597,6 +603,9 @@ const enUS = {
     taskDebugHint:
       'For troubleshooting the callback -> queue -> worker flow only. The four main content sections above stay unchanged.',
     contentCitationBadge: 'Content Citation',
+    manualMarkedArticle: 'External Article',
+    markAsExternalArticle: 'Mark as external article',
+    markedArticleSaved: 'Marked as external article.',
     noQuestions: 'No hot questions for the current filters',
     noCitationRanking: 'No attributable citations in the current window',
     noCitedArticles: 'No content citations in the current window',
@@ -708,6 +717,41 @@ const enUS = {
       },
     },
   },
+  trackingMarkedArticles: {
+    title: 'External Article Marks',
+    description:
+      'Mark official-site, media, or third-party pages as external articles when they cannot be connected automatically. Marks are retained for 6 months.',
+    createAction: 'Mark Article',
+    createTitle: 'Mark External Article',
+    editTitle: 'Edit External Article',
+    openOriginal: 'Open original page',
+    deleteConfirmTitle: 'Delete this external article mark?',
+    total: '{count} total',
+    filters: {
+      domain: 'Search domain, e.g. example.com',
+      title: 'Search article title',
+      createdFrom: 'Start time',
+      createdTo: 'End time',
+    },
+    form: {
+      articleTitle: 'Article title',
+      articleTitlePlaceholder: 'Enter article title',
+      originalUrl: 'Original URL',
+      originalUrlPlaceholder: 'https://example.com/article',
+    },
+    columns: {
+      articleTitle: 'Article Title',
+      domain: 'Domain',
+      url: 'Original URL',
+      markedAt: 'Marked At',
+      expiresAt: 'Retained Until',
+    },
+    messages: {
+      required: 'Enter article title and original URL.',
+      saved: 'External article mark saved.',
+      deleted: 'External article mark deleted.',
+    },
+  },
   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 a7032af..ce7602f 100644
--- a/apps/admin-web/src/i18n/messages/zh-CN.ts
+++ b/apps/admin-web/src/i18n/messages/zh-CN.ts
@@ -91,6 +91,7 @@ const zhCN = {
     brands: '品牌和词库',
     tracking: '数据追踪',
     trackingDetail: '数据详情',
+    trackingMarkedArticles: '外部文章标记',
     contentManagement: '内容管理',
     knowledge: '知识库',
     images: '图片管理',
@@ -264,6 +265,10 @@ const zhCN = {
       title: '数据详情',
       description: '围绕插件采样快照查看品牌表现、平台矩阵、高频问题和引用归因。',
     },
+    trackingMarkedArticles: {
+      title: '外部文章标记',
+      description: '维护用户手动标记的外部文章 URL，让它们参与引用文章和引用排行统计。',
+    },
     trackingQuestion: {
       title: '问题详情',
       description: '按问题查看大模型回答、引用来源、引用分析和内容引用。',
@@ -561,7 +566,7 @@ const zhCN = {
     backToQuestions: '返回问题列表',
     citationRanking: 'Citation Ranking',
     citationRankingTitle: '引用排行',
-    citationRankingHint: '按发布外链主体归因 SaaS 发文在模型引用来源中的出现次数与占比。',
+    citationRankingHint: '按发布外链和手动标记 URL 归因外部文章在模型引用来源中的出现次数与占比。',
     citationWindow7: '近 7 天',
     citationWindow30: '近 30 天',
     citationWindowLabel: '近 {days} 天',
@@ -578,6 +583,9 @@ const zhCN = {
     taskDebugTitle: '异步任务调试',
     taskDebugHint: '仅用于排查 callback -> queue -> worker 的异步流转，不影响上方四块主内容。',
     contentCitationBadge: '内容引用',
+    manualMarkedArticle: '外部文章',
+    markAsExternalArticle: '标记为外部文章',
+    markedArticleSaved: '已标记为外部文章',
     noQuestions: '当前筛选条件下暂无高频问题',
     noCitationRanking: '当前时间窗口内暂无可归因引用',
     noCitedArticles: '当前时间窗口内暂无内容引用',
@@ -688,6 +696,40 @@ const zhCN = {
       },
     },
   },
+  trackingMarkedArticles: {
+    title: '外部文章标记',
+    description: '把无法自动对接的官网、媒体或第三方页面标记为外部文章，系统会在 6 个月内用于引用归因。',
+    createAction: '标记文章',
+    createTitle: '标记外部文章',
+    editTitle: '编辑外部文章',
+    openOriginal: '打开原始页面',
+    deleteConfirmTitle: '删除这条外部文章标记？',
+    total: '共 {count} 条',
+    filters: {
+      domain: '按域名搜索，如 example.com',
+      title: '按文章名称搜索',
+      createdFrom: '开始时间',
+      createdTo: '结束时间',
+    },
+    form: {
+      articleTitle: '文章名称',
+      articleTitlePlaceholder: '输入文章标题',
+      originalUrl: '原始 URL',
+      originalUrlPlaceholder: 'https://example.com/article',
+    },
+    columns: {
+      articleTitle: '文章名称',
+      domain: '域名',
+      url: '原始 URL',
+      markedAt: '标记时间',
+      expiresAt: '保留至',
+    },
+    messages: {
+      required: '请填写文章名称和原始 URL',
+      saved: '外部文章标记已保存',
+      deleted: '外部文章标记已删除',
+    },
+  },
   templateMeta: {
     top_x_article: {
       eyebrow: '榜单内容',
diff --git a/apps/admin-web/src/layouts/AppShell.vue b/apps/admin-web/src/layouts/AppShell.vue
index d4cb5ef..3609c28 100644
--- a/apps/admin-web/src/layouts/AppShell.vue
+++ b/apps/admin-web/src/layouts/AppShell.vue
@@ -377,7 +377,14 @@ const navSections = computed<NavSection[]>(() => {
     {
       key: 'tracking',
       title: t('nav.tracking'),
-      items: [{ key: '/tracking', label: t('nav.trackingDetail'), icon: LineChartOutlined }],
+      items: [
+        { key: '/tracking', label: t('nav.trackingDetail'), icon: LineChartOutlined },
+        {
+          key: '/tracking/marked-articles',
+          label: t('nav.trackingMarkedArticles'),
+          icon: FileTextOutlined,
+        },
+      ],
     },
     {
       key: 'contentManagement',
diff --git a/apps/admin-web/src/lib/api.ts b/apps/admin-web/src/lib/api.ts
index 9861990..8a1bd54 100644
--- a/apps/admin-web/src/lib/api.ts
+++ b/apps/admin-web/src/lib/api.ts
@@ -103,6 +103,9 @@ import type {
   MonitoringCitationSummaryResponse,
   MonitoringCollectNowResponse,
   MonitoringDashboardCompositeResponse,
+  MonitoringMarkedArticle,
+  MonitoringMarkedArticleListResponse,
+  MonitoringMarkedArticleRequest,
   MonitoringQuestionDetailResponse,
   PasswordPublicKeyResponse,
   PlatformAccount,
@@ -1533,6 +1536,34 @@ export const monitoringApi = {
       },
     )
   },
+  listMarkedArticles(params?: {
+    page?: number
+    page_size?: number
+    domain?: string
+    title?: string
+    created_from?: string
+    created_to?: string
+  }) {
+    return apiClient.get<MonitoringMarkedArticleListResponse>(
+      '/api/tenant/monitoring/marked-articles',
+      { params },
+    )
+  },
+  createMarkedArticle(payload: MonitoringMarkedArticleRequest) {
+    return apiClient.post<MonitoringMarkedArticle, MonitoringMarkedArticleRequest>(
+      '/api/tenant/monitoring/marked-articles',
+      payload,
+    )
+  },
+  updateMarkedArticle(id: number, payload: MonitoringMarkedArticleRequest) {
+    return apiClient.put<MonitoringMarkedArticle, MonitoringMarkedArticleRequest>(
+      `/api/tenant/monitoring/marked-articles/${id}`,
+      payload,
+    )
+  },
+  deleteMarkedArticle(id: number) {
+    return apiClient.remove<{ ok: boolean }>(`/api/tenant/monitoring/marked-articles/${id}`)
+  },
   questionDetail(
     brandId: number,
     questionId: number,
diff --git a/apps/admin-web/src/lib/display.ts b/apps/admin-web/src/lib/display.ts
index c76385c..a684c82 100644
--- a/apps/admin-web/src/lib/display.ts
+++ b/apps/admin-web/src/lib/display.ts
@@ -26,11 +26,24 @@ const publishStatusMap: Record<string, { label: string; color: string }> = {
   blocked_by_compliance: { label: 'status.publish.blocked_by_compliance', color: 'error' },
 }
 
+const goTimestampWithZonePattern =
+  /^(\d{4}-\d{2}-\d{2})\s+(\d{2}:\d{2}:\d{2})(\.\d+)?\s+([+-]\d{2})(\d{2})(?:\s+\S+)?$/
+
+function normalizeDateTimeValue(value: string): string {
+  const trimmed = value.trim()
+  const match = trimmed.match(goTimestampWithZonePattern)
+  if (!match) {
+    return trimmed
+  }
+  const [, date, time, fraction = '', hourOffset, minuteOffset] = match
+  return `${date}T${time}${fraction}${hourOffset}:${minuteOffset}`
+}
+
 export function formatDateTime(value?: string | null, pattern = 'YYYY-MM-DD HH:mm'): string {
   if (!value) {
     return '--'
   }
-  const parsed = dayjs(value)
+  const parsed = dayjs(normalizeDateTimeValue(value))
   return parsed.isValid() ? parsed.format(pattern) : value
 }
 
diff --git a/apps/admin-web/src/router/index.ts b/apps/admin-web/src/router/index.ts
index d67d3a2..c84f0a3 100644
--- a/apps/admin-web/src/router/index.ts
+++ b/apps/admin-web/src/router/index.ts
@@ -239,6 +239,16 @@ const router = createRouter({
             navKey: '/tracking',
           },
         },
+        {
+          path: 'tracking/marked-articles',
+          name: 'tracking-marked-articles',
+          component: () => import('@/views/TrackingMarkedArticlesView.vue'),
+          meta: {
+            titleKey: 'route.trackingMarkedArticles.title',
+            descriptionKey: 'route.trackingMarkedArticles.description',
+            navKey: '/tracking/marked-articles',
+          },
+        },
         {
           path: 'tracking/questions/:brandId/:questionId',
           name: 'tracking-question-detail',
diff --git a/apps/admin-web/src/views/TrackingMarkedArticlesView.vue b/apps/admin-web/src/views/TrackingMarkedArticlesView.vue
new file mode 100644
index 0000000..f8636ca
--- /dev/null
+++ b/apps/admin-web/src/views/TrackingMarkedArticlesView.vue
@@ -0,0 +1,472 @@
+<script setup lang="ts">
+import {
+  DeleteOutlined,
+  EditOutlined,
+  EyeOutlined,
+  PlusOutlined,
+  ReloadOutlined,
+  SearchOutlined,
+} from '@ant-design/icons-vue'
+import type { MonitoringMarkedArticle, MonitoringMarkedArticleRequest } from '@geo/shared-types'
+import { useMutation, useQuery, useQueryClient } from '@tanstack/vue-query'
+import type { TableColumnsType, TablePaginationConfig } from 'ant-design-vue'
+import { message, Modal } from 'ant-design-vue'
+import type { Dayjs } from 'dayjs'
+import { computed, reactive, ref } from 'vue'
+import { useI18n } from 'vue-i18n'
+
+import PageHero from '@/components/PageHero.vue'
+import { monitoringApi } from '@/lib/api'
+import { formatDateTime } from '@/lib/display'
+import { formatError } from '@/lib/errors'
+import { useCompanyStore } from '@/stores/company'
+
+const { t } = useI18n()
+const queryClient = useQueryClient()
+const companyStore = useCompanyStore()
+
+const page = ref(1)
+const pageSize = ref(10)
+const createdRange = ref<[Dayjs, Dayjs] | null>(null)
+const draftFilters = reactive({
+  domain: '',
+  title: '',
+})
+const appliedFilters = reactive({
+  domain: '',
+  title: '',
+  created_from: '',
+  created_to: '',
+})
+const modalOpen = ref(false)
+const editingArticle = ref<MonitoringMarkedArticle | null>(null)
+const formState = reactive({
+  article_title: '',
+  original_url: '',
+})
+
+const listParams = computed(() => ({
+  page: page.value,
+  page_size: pageSize.value,
+  domain: appliedFilters.domain || undefined,
+  title: appliedFilters.title || undefined,
+  created_from: appliedFilters.created_from || undefined,
+  created_to: appliedFilters.created_to || undefined,
+}))
+
+const markedArticlesQuery = useQuery({
+  queryKey: computed(() => ['tracking', 'marked-articles', listParams.value]),
+  queryFn: () => monitoringApi.listMarkedArticles(listParams.value),
+})
+
+const markedArticles = computed(() => markedArticlesQuery.data.value?.items ?? [])
+const pageInfo = computed(() => markedArticlesQuery.data.value?.page)
+const total = computed(() => pageInfo.value?.total ?? 0)
+const modalTitle = computed(() =>
+  editingArticle.value
+    ? t('trackingMarkedArticles.editTitle')
+    : t('trackingMarkedArticles.createTitle'),
+)
+
+const columns = computed<TableColumnsType<MonitoringMarkedArticle>>(() => [
+  {
+    title: t('trackingMarkedArticles.columns.articleTitle'),
+    dataIndex: 'article_title',
+    key: 'article_title',
+    width: 320,
+  },
+  {
+    title: t('trackingMarkedArticles.columns.domain'),
+    dataIndex: 'registrable_domain',
+    key: 'registrable_domain',
+    width: 180,
+  },
+  {
+    title: t('trackingMarkedArticles.columns.url'),
+    dataIndex: 'original_url',
+    key: 'original_url',
+    ellipsis: true,
+  },
+  {
+    title: t('trackingMarkedArticles.columns.markedAt'),
+    dataIndex: 'marked_at',
+    key: 'marked_at',
+    width: 180,
+  },
+  {
+    title: t('trackingMarkedArticles.columns.expiresAt'),
+    dataIndex: 'expires_at',
+    key: 'expires_at',
+    width: 180,
+  },
+  {
+    title: t('common.actions'),
+    key: 'actions',
+    width: 140,
+    fixed: 'right',
+    align: 'right' as const,
+  },
+])
+
+const createMutation = useMutation({
+  mutationFn: (payload: MonitoringMarkedArticleRequest) =>
+    monitoringApi.createMarkedArticle(payload),
+  onSuccess: async () => {
+    message.success(t('trackingMarkedArticles.messages.saved'))
+    closeModal()
+    await invalidateMarkedArticles()
+  },
+  onError: (error) => message.error(formatError(error)),
+})
+
+const updateMutation = useMutation({
+  mutationFn: (payload: { id: number; body: MonitoringMarkedArticleRequest }) =>
+    monitoringApi.updateMarkedArticle(payload.id, payload.body),
+  onSuccess: async () => {
+    message.success(t('trackingMarkedArticles.messages.saved'))
+    closeModal()
+    await invalidateMarkedArticles()
+  },
+  onError: (error) => message.error(formatError(error)),
+})
+
+const deleteMutation = useMutation({
+  mutationFn: (id: number) => monitoringApi.deleteMarkedArticle(id),
+  onSuccess: async () => {
+    message.success(t('trackingMarkedArticles.messages.deleted'))
+    await invalidateMarkedArticles()
+  },
+  onError: (error) => message.error(formatError(error)),
+})
+
+const saving = computed(() => createMutation.isPending.value || updateMutation.isPending.value)
+
+function applyFilters(): void {
+  page.value = 1
+  appliedFilters.domain = draftFilters.domain.trim()
+  appliedFilters.title = draftFilters.title.trim()
+  appliedFilters.created_from = createdRange.value?.[0]?.toISOString() ?? ''
+  appliedFilters.created_to = createdRange.value?.[1]?.toISOString() ?? ''
+}
+
+function resetFilters(): void {
+  draftFilters.domain = ''
+  draftFilters.title = ''
+  createdRange.value = null
+  applyFilters()
+}
+
+function openCreateModal(): void {
+  editingArticle.value = null
+  formState.article_title = ''
+  formState.original_url = ''
+  modalOpen.value = true
+}
+
+function openEditModal(record: MonitoringMarkedArticle): void {
+  editingArticle.value = record
+  formState.article_title = record.article_title
+  formState.original_url = record.original_url
+  modalOpen.value = true
+}
+
+function closeModal(): void {
+  modalOpen.value = false
+  editingArticle.value = null
+  formState.article_title = ''
+  formState.original_url = ''
+}
+
+async function submitForm(): Promise<void> {
+  const payload: MonitoringMarkedArticleRequest = {
+    article_title: formState.article_title.trim(),
+    original_url: formState.original_url.trim(),
+    brand_id: companyStore.currentBrandId ?? null,
+  }
+  if (!payload.article_title || !payload.original_url) {
+    message.warning(t('trackingMarkedArticles.messages.required'))
+    return
+  }
+  if (editingArticle.value) {
+    await updateMutation.mutateAsync({ id: editingArticle.value.id, body: payload })
+    return
+  }
+  await createMutation.mutateAsync(payload)
+}
+
+function confirmDelete(record: MonitoringMarkedArticle): void {
+  Modal.confirm({
+    title: t('trackingMarkedArticles.deleteConfirmTitle'),
+    content: record.article_title,
+    okText: t('common.delete'),
+    okType: 'danger',
+    cancelText: t('common.cancel'),
+    onOk: () => deleteMutation.mutateAsync(record.id),
+  })
+}
+
+function openURL(url: string): void {
+  const normalized = url.trim()
+  if (!normalized) {
+    return
+  }
+  window.open(normalized, '_blank', 'noopener,noreferrer')
+}
+
+function handleTableChange(pagination: TablePaginationConfig): void {
+  page.value = pagination.current ?? 1
+  pageSize.value = pagination.pageSize ?? pageSize.value
+}
+
+function renderTotal(count: number): string {
+  return t('trackingMarkedArticles.total', { count })
+}
+
+async function invalidateMarkedArticles(): Promise<void> {
+  await Promise.all([
+    queryClient.invalidateQueries({ queryKey: ['tracking', 'marked-articles'] }),
+    queryClient.invalidateQueries({ queryKey: ['tracking'] }),
+  ])
+}
+</script>
+
+<template>
+  <section class="marked-articles-page">
+    <PageHero
+      :title="t('trackingMarkedArticles.title')"
+      :description="t('trackingMarkedArticles.description')"
+    >
+      <template #actions>
+        <a-button @click="markedArticlesQuery.refetch()">
+          <template #icon><ReloadOutlined /></template>
+          {{ t('common.refresh') }}
+        </a-button>
+        <a-button type="primary" @click="openCreateModal">
+          <template #icon><PlusOutlined /></template>
+          {{ t('trackingMarkedArticles.createAction') }}
+        </a-button>
+      </template>
+    </PageHero>
+
+    <a-card class="marked-articles-card">
+      <div class="marked-articles-filters">
+        <a-input
+          v-model:value="draftFilters.domain"
+          allow-clear
+          class="marked-articles-filters__domain"
+          :placeholder="t('trackingMarkedArticles.filters.domain')"
+          @pressEnter="applyFilters"
+        >
+          <template #prefix><SearchOutlined /></template>
+        </a-input>
+        <a-input
+          v-model:value="draftFilters.title"
+          allow-clear
+          class="marked-articles-filters__title"
+          :placeholder="t('trackingMarkedArticles.filters.title')"
+          @pressEnter="applyFilters"
+        />
+        <a-range-picker
+          v-model:value="createdRange"
+          allow-clear
+          show-time
+          class="marked-articles-filters__range"
+          format="YYYY-MM-DD HH:mm"
+          :placeholder="[
+            t('trackingMarkedArticles.filters.createdFrom'),
+            t('trackingMarkedArticles.filters.createdTo'),
+          ]"
+        />
+        <div class="marked-articles-filters__actions">
+          <a-button type="primary" @click="applyFilters">{{ t('common.search') }}</a-button>
+          <a-button @click="resetFilters">{{ t('common.reset') }}</a-button>
+        </div>
+      </div>
+
+      <a-table
+        row-key="id"
+        class="modern-table marked-articles-table"
+        :columns="columns"
+        :data-source="markedArticles"
+        :loading="markedArticlesQuery.isLoading.value"
+        :pagination="{
+          current: page,
+          pageSize,
+          total,
+          showSizeChanger: true,
+          showTotal: renderTotal,
+        }"
+        @change="handleTableChange"
+      >
+        <template #bodyCell="{ column, record }">
+          <template v-if="column.key === 'article_title'">
+            <div class="marked-article-title">
+              <strong :title="record.article_title">{{ record.article_title }}</strong>
+              <span>{{ record.publish_platform }}</span>
+            </div>
+          </template>
+          <template v-else-if="column.key === 'registrable_domain'">
+            <a-tag color="blue">{{ record.registrable_domain }}</a-tag>
+          </template>
+          <template v-else-if="column.key === 'original_url'">
+            <a
+              :href="record.original_url"
+              target="_blank"
+              rel="noreferrer"
+              class="marked-article-url"
+              :title="record.original_url"
+            >
+              {{ record.original_url }}
+            </a>
+          </template>
+          <template v-else-if="column.key === 'marked_at'">
+            {{ formatDateTime(record.marked_at) }}
+          </template>
+          <template v-else-if="column.key === 'expires_at'">
+            {{ formatDateTime(record.expires_at) }}
+          </template>
+          <template v-else-if="column.key === 'actions'">
+            <div class="marked-article-actions">
+              <a-tooltip :title="t('trackingMarkedArticles.openOriginal')">
+                <a-button type="text" shape="circle" @click="openURL(record.original_url)">
+                  <template #icon><EyeOutlined /></template>
+                </a-button>
+              </a-tooltip>
+              <a-tooltip :title="t('common.edit')">
+                <a-button type="text" shape="circle" @click="openEditModal(record)">
+                  <template #icon><EditOutlined /></template>
+                </a-button>
+              </a-tooltip>
+              <a-tooltip :title="t('common.delete')">
+                <a-button
+                  type="text"
+                  danger
+                  shape="circle"
+                  :loading="deleteMutation.isPending.value"
+                  @click="confirmDelete(record)"
+                >
+                  <template #icon><DeleteOutlined /></template>
+                </a-button>
+              </a-tooltip>
+            </div>
+          </template>
+        </template>
+      </a-table>
+    </a-card>
+
+    <a-modal
+      v-model:open="modalOpen"
+      :title="modalTitle"
+      :confirm-loading="saving"
+      width="560px"
+      @ok="submitForm"
+      @cancel="closeModal"
+    >
+      <a-form layout="vertical" class="marked-article-form">
+        <a-form-item :label="t('trackingMarkedArticles.form.articleTitle')" required>
+          <a-input
+            v-model:value="formState.article_title"
+            :maxlength="160"
+            :placeholder="t('trackingMarkedArticles.form.articleTitlePlaceholder')"
+          />
+        </a-form-item>
+        <a-form-item :label="t('trackingMarkedArticles.form.originalUrl')" required>
+          <a-input
+            v-model:value="formState.original_url"
+            :placeholder="t('trackingMarkedArticles.form.originalUrlPlaceholder')"
+          />
+        </a-form-item>
+      </a-form>
+    </a-modal>
+  </section>
+</template>
+
+<style scoped>
+.marked-articles-page {
+  display: flex;
+  flex-direction: column;
+  gap: 20px;
+}
+
+.marked-articles-card {
+  border: 1px solid #edf1f7;
+  border-radius: 12px;
+}
+
+.marked-articles-filters {
+  display: grid;
+  grid-template-columns: minmax(180px, 240px) minmax(220px, 1fr) minmax(280px, 360px) auto;
+  gap: 12px;
+  align-items: center;
+  margin-bottom: 18px;
+}
+
+.marked-articles-filters__actions {
+  display: inline-flex;
+  gap: 8px;
+  justify-content: flex-end;
+}
+
+.marked-articles-table :deep(.ant-table-cell) {
+  vertical-align: middle;
+}
+
+.marked-article-title {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+  min-width: 0;
+}
+
+.marked-article-title strong {
+  overflow: hidden;
+  color: #111827;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.marked-article-title span {
+  color: #8a96aa;
+  font-size: 12px;
+}
+
+.marked-article-url {
+  display: inline-block;
+  max-width: 100%;
+  overflow: hidden;
+  color: #2563eb;
+  text-overflow: ellipsis;
+  vertical-align: middle;
+  white-space: nowrap;
+}
+
+.marked-article-actions {
+  display: inline-flex;
+  gap: 4px;
+}
+
+.marked-article-form {
+  padding-top: 8px;
+}
+
+@media (max-width: 1100px) {
+  .marked-articles-filters {
+    grid-template-columns: 1fr 1fr;
+  }
+
+  .marked-articles-filters__range,
+  .marked-articles-filters__actions {
+    width: 100%;
+  }
+
+  .marked-articles-filters__actions {
+    justify-content: flex-start;
+  }
+}
+
+@media (max-width: 720px) {
+  .marked-articles-filters {
+    grid-template-columns: 1fr;
+  }
+}
+</style>
diff --git a/apps/admin-web/src/views/TrackingQuestionDetailView.vue b/apps/admin-web/src/views/TrackingQuestionDetailView.vue
index f78b4a4..9ad14aa 100644
--- a/apps/admin-web/src/views/TrackingQuestionDetailView.vue
+++ b/apps/admin-web/src/views/TrackingQuestionDetailView.vue
@@ -1,12 +1,13 @@
 <script setup lang="ts">
-import { ArrowLeftOutlined, CopyOutlined } from '@ant-design/icons-vue'
+import { ArrowLeftOutlined, BookOutlined, CopyOutlined } from '@ant-design/icons-vue'
 import type {
   MonitoringQuestionCitationAnalysisItem,
   MonitoringQuestionDetailCitation,
   MonitoringQuestionDetailPlatform,
   MonitoringSourceItem,
 } from '@geo/shared-types'
-import { useQuery } from '@tanstack/vue-query'
+import { useMutation, useQuery, useQueryClient } from '@tanstack/vue-query'
+import { message } from 'ant-design-vue'
 import dayjs from 'dayjs'
 import { computed, nextTick, onBeforeUnmount, ref, watch } from 'vue'
 import { useI18n } from 'vue-i18n'
@@ -22,6 +23,7 @@ import { useCompanyStore } from '@/stores/company'
 const { t } = useI18n()
 const route = useRoute()
 const router = useRouter()
+const queryClient = useQueryClient()
 const companyStore = useCompanyStore()
 
 const trackingMaxHistoryDays = 30
@@ -179,6 +181,7 @@ type TrackingAnalyzedContentCitation = {
   citationCount: number
   citationRate: number | null
   citedURL: string | null
+  sourceType: string | null
 }
 
 type TrackingCitationSourceLookupItem = {
@@ -202,6 +205,20 @@ const shouldShowInlineContentCitations = computed(() => {
   return activeInlineContentCitations.value.length > 0
 })
 
+const markCitationMutation = useMutation({
+  mutationFn: (citation: MonitoringQuestionDetailCitation) =>
+    monitoringApi.createMarkedArticle({
+      article_title: resolveExternalArticleTitle(citation),
+      original_url: citation.cited_url,
+      brand_id: brandId.value ?? null,
+    }),
+  onSuccess: async () => {
+    message.success(t('tracking.markedArticleSaved'))
+    await queryClient.invalidateQueries({ queryKey: ['tracking'] })
+  },
+  onError: (error) => message.error(formatError(error)),
+})
+
 watch(activePlatformId, () => {
   clearCitationHighlight()
 })
@@ -248,6 +265,13 @@ function openImitationCreate(
   })
 }
 
+function markCitationAsExternal(citation: MonitoringQuestionDetailCitation): void {
+  if (!canMarkCitationAsExternal(citation, activePlatform.value?.ai_platform_id)) {
+    return
+  }
+  markCitationMutation.mutate(citation)
+}
+
 function formatPercent(value: number | null | undefined): string {
   if (value === null || value === undefined) {
     return '--'
@@ -311,6 +335,37 @@ function resolveCitationTitle(citation: MonitoringQuestionDetailCitation): strin
   return citation.cited_title || citation.article_title || citation.cited_url
 }
 
+function resolveExternalArticleTitle(citation: MonitoringQuestionDetailCitation): string {
+  const title = String(citation.cited_title ?? citation.article_title ?? '').trim()
+  if (title) {
+    return title
+  }
+  return String(citation.site_name ?? citation.cited_url).trim()
+}
+
+function isManualMarkedCitation(
+  citation: MonitoringQuestionDetailCitation | null | undefined,
+): boolean {
+  return citation?.source_type === 'manual_mark'
+}
+
+function canMarkCitationAsExternal(
+  citation: MonitoringQuestionDetailCitation | null | undefined,
+  platformId: string | null | undefined,
+): boolean {
+  if (!citation || !supportsContentCitationDisplay(platformId)) {
+    return false
+  }
+  if (!String(citation.cited_url ?? '').trim()) {
+    return false
+  }
+  return (
+    !citation.article_id &&
+    citation.source_type !== 'published_article' &&
+    !isManualMarkedCitation(citation)
+  )
+}
+
 function isLinkedInlineCitationPlatform(platformId: string | null | undefined): boolean {
   return platformId === 'yuanbao'
 }
@@ -1118,6 +1173,7 @@ function analyzeInlineContentCitations(
         citationCount: item.citationCount,
         citationRate: item.citationCount / totalCitationCount,
         citedURL: item.url,
+        sourceType: null,
       }))
   }
 
@@ -1151,6 +1207,7 @@ function analyzeInlineContentCitations(
           citationCount: item.citationCount,
           citationRate: item.citationCount / totalCitationCount,
           citedURL: item.url,
+          sourceType: null,
         }
       })
   }
@@ -1199,6 +1256,7 @@ function analyzeInlineContentCitations(
           citationCount,
           citationRate: citationCount / totalCitationCount,
           citedURL,
+          sourceType: citation?.source_type ?? null,
         },
       ]
     })
@@ -1503,17 +1561,36 @@ const contentCitationColumns = computed(() => [
                     >
                       {{ resolveCitationTitle(citation) }}
                     </span>
-                    <a-tooltip :title="t('tracking.imitationAction')">
-                      <button
-                        type="button"
-                        class="tracking-question-imitation-trigger tracking-question-imitation-trigger--source"
-                        @click.stop="
-                          openImitationCreate(citation.cited_url, resolveCitationTitle(citation))
-                        "
+                    <div class="tracking-question-source-card__actions">
+                      <a-tooltip
+                        v-if="canMarkCitationAsExternal(citation, activePlatform?.ai_platform_id)"
+                        :title="t('tracking.markAsExternalArticle')"
                       >
-                        <CopyOutlined />
-                      </button>
-                    </a-tooltip>
+                        <button
+                          type="button"
+                          class="tracking-question-imitation-trigger"
+                          :disabled="markCitationMutation.isPending.value"
+                          @click.stop="markCitationAsExternal(citation)"
+                          @keydown.enter.stop.prevent="markCitationAsExternal(citation)"
+                        >
+                          <BookOutlined />
+                        </button>
+                      </a-tooltip>
+                      <a-tooltip :title="t('tracking.imitationAction')">
+                        <button
+                          type="button"
+                          class="tracking-question-imitation-trigger"
+                          @click.stop="
+                            openImitationCreate(citation.cited_url, resolveCitationTitle(citation))
+                          "
+                          @keydown.enter.stop.prevent="
+                            openImitationCreate(citation.cited_url, resolveCitationTitle(citation))
+                          "
+                        >
+                          <CopyOutlined />
+                        </button>
+                      </a-tooltip>
+                    </div>
                     <a-tag
                       v-if="
                         citation.article_id &&
@@ -1524,6 +1601,16 @@ const contentCitationColumns = computed(() => [
                     >
                       {{ t('tracking.contentCitationBadge') }}
                     </a-tag>
+                    <a-tag
+                      v-else-if="
+                        isManualMarkedCitation(citation) &&
+                        supportsContentCitationDisplay(activePlatform?.ai_platform_id)
+                      "
+                      color="green"
+                      class="tracking-question-source-card__badge"
+                    >
+                      {{ t('tracking.manualMarkedArticle') }}
+                    </a-tag>
                   </div>
                   <div class="tracking-question-source-card__link">
                     {{ citation.cited_url }}
@@ -1627,16 +1714,20 @@ const contentCitationColumns = computed(() => [
                 <template #bodyCell="{ column, record }">
                   <template v-if="column.key === 'contentName'">
                     <div class="cell-primary-stack">
-                      <a
-                        v-if="record.citedURL"
-                        :href="record.citedURL"
-                        target="_blank"
-                        rel="noreferrer"
-                        :title="record.contentName"
-                        class="table-link"
-                      >
-                        {{ record.contentName }}
-                      </a>
+                      <template v-if="record.citedURL">
+                        <a
+                          :href="record.citedURL"
+                          target="_blank"
+                          rel="noreferrer"
+                          :title="record.contentName"
+                          class="table-link"
+                        >
+                          {{ record.contentName }}
+                        </a>
+                        <small v-if="record.sourceType === 'manual_mark'" class="meta-subtext">
+                          {{ t('tracking.manualMarkedArticle') }}
+                        </small>
+                      </template>
                       <strong v-else class="table-text" :title="record.contentName">
                         {{ record.contentName }}
                       </strong>
@@ -2139,10 +2230,17 @@ const contentCitationColumns = computed(() => [
   background: #eff6ff;
 }
 
-.tracking-question-imitation-trigger--source {
+.tracking-question-imitation-trigger:disabled {
+  cursor: not-allowed;
+  opacity: 0.55;
+}
+
+.tracking-question-source-card__actions {
   position: absolute;
   top: 50%;
   right: 16px;
+  display: inline-flex;
+  gap: 6px;
   transform: translateY(calc(-50% + 1px));
 }
 
@@ -2152,9 +2250,8 @@ const contentCitationColumns = computed(() => [
   transform: translateY(0);
 }
 
-.tracking-question-source-card:hover .tracking-question-imitation-trigger--source,
-.tracking-question-source-card:focus-within .tracking-question-imitation-trigger--source {
-  opacity: 1;
+.tracking-question-source-card:hover .tracking-question-source-card__actions,
+.tracking-question-source-card:focus-within .tracking-question-source-card__actions {
   transform: translateY(-50%);
 }
 
diff --git a/apps/admin-web/src/views/TrackingView.vue b/apps/admin-web/src/views/TrackingView.vue
index 3abe80e..12e7ed7 100644
--- a/apps/admin-web/src/views/TrackingView.vue
+++ b/apps/admin-web/src/views/TrackingView.vue
@@ -1,12 +1,12 @@
 <script setup lang="ts">
 import {
-  EyeOutlined,
-  ReloadOutlined,
-  QuestionCircleOutlined,
   ClockCircleOutlined,
+  EyeOutlined,
+  FileTextOutlined,
+  QuestionCircleOutlined,
+  ReloadOutlined,
   RightOutlined,
   SearchOutlined,
-  FileTextOutlined,
 } from '@ant-design/icons-vue'
 import type {
   DesktopAccountInfo,
@@ -189,7 +189,10 @@ watch(
   () => route.query.question_id,
   (value) => {
     const requestedQuestionId = parseNumericQuery(route.query.question_id)
-    if (missingRequestedQuestionId.value && missingRequestedQuestionId.value !== requestedQuestionId) {
+    if (
+      missingRequestedQuestionId.value &&
+      missingRequestedQuestionId.value !== requestedQuestionId
+    ) {
       missingRequestedQuestionId.value = null
     }
     if (value || selectedBrandId.value) {
@@ -691,9 +694,18 @@ watch([selectedBrandId, selectedQuestionId, selectedPlatformId, selectedBusiness
   hotQuestionPage.value = 1
 })
 
-watch([selectedBrandId, selectedQuestionId, selectedPlatformId, selectedBusinessDate, selectedCitationWindowDays], () => {
-  citedArticlePage.value = 1
-})
+watch(
+  [
+    selectedBrandId,
+    selectedQuestionId,
+    selectedPlatformId,
+    selectedBusinessDate,
+    selectedCitationWindowDays,
+  ],
+  () => {
+    citedArticlePage.value = 1
+  },
+)
 
 function openQuestion(question: MonitoringHotQuestion): void {
   if (!selectedBrandId.value) {
@@ -718,10 +730,30 @@ function openQuestion(question: MonitoringHotQuestion): void {
 }
 
 function openCitedArticle(item: MonitoringCitedArticle): void {
+  if (item.source_type === 'manual_mark') {
+    openExternalURL(item.source_url)
+    return
+  }
+  if (!item.article_id) {
+    openExternalURL(item.source_url)
+    return
+  }
   selectedArticleId.value = item.article_id
   articleDrawerOpen.value = true
 }
 
+function citedArticleKey(item: MonitoringCitedArticle): string {
+  return `${item.source_type}:${item.source_id || item.source_url || item.article_id || item.article_title}`
+}
+
+function openExternalURL(url: string | null | undefined): void {
+  const normalized = String(url ?? '').trim()
+  if (!normalized) {
+    return
+  }
+  window.open(normalized, '_blank', 'noopener,noreferrer')
+}
+
 function formatPercent(value: number | null | undefined): string {
   if (value === null || value === undefined) {
     return '--'
@@ -1308,7 +1340,10 @@ function disableTrackingDate(current: dayjs.Dayjs): boolean {
                 <strong>{{ question.question_text }}</strong>
                 <div class="mention-rate-container">
                   <span class="mention-rate-label">{{ t('tracking.metrics.mentionRate') }}</span>
-                  <span class="mention-rate-badge" :class="getMentionRateClass(question.mention_rate)">
+                  <span
+                    class="mention-rate-badge"
+                    :class="getMentionRateClass(question.mention_rate)"
+                  >
                     {{ formatPercent(question.mention_rate) }}
                   </span>
                   <div class="mention-rate-track">
@@ -1368,7 +1403,7 @@ function disableTrackingDate(current: dayjs.Dayjs): boolean {
         <div v-if="citedArticles.length" class="article-list">
           <div
             v-for="item in citedArticles"
-            :key="item.article_id"
+            :key="citedArticleKey(item)"
             class="article-list__item"
           >
             <div class="article-list__item-left">
@@ -1377,7 +1412,13 @@ function disableTrackingDate(current: dayjs.Dayjs): boolean {
               </div>
               <div class="article-list__item-content">
                 <strong>{{ item.article_title }}</strong>
-                <span class="article-platform-tag">{{ item.publish_platform }}</span>
+                <span class="article-platform-tag">
+                  {{
+                    item.source_type === 'manual_mark'
+                      ? t('tracking.manualMarkedArticle')
+                      : item.publish_platform
+                  }}
+                </span>
               </div>
             </div>
             <div class="article-list__side">
@@ -1693,7 +1734,9 @@ function disableTrackingDate(current: dayjs.Dayjs): boolean {
 .tracking-list-search.ant-input-affix-wrapper:focus {
   background-color: #ffffff;
   border-color: #1f5cff;
-  box-shadow: 0 0 0 3px rgba(31, 92, 255, 0.1), 0 4px 12px rgba(31, 92, 255, 0.05);
+  box-shadow:
+    0 0 0 3px rgba(31, 92, 255, 0.1),
+    0 4px 12px rgba(31, 92, 255, 0.05);
 }
 
 .tracking-list-search :deep(.ant-input) {
@@ -2035,7 +2078,9 @@ function disableTrackingDate(current: dayjs.Dayjs): boolean {
 .detail-citation-list__item:hover {
   background: #ffffff;
   border-color: rgba(31, 92, 255, 0.25);
-  box-shadow: 0 10px 25px -5px rgba(31, 92, 255, 0.08), 0 8px 10px -6px rgba(31, 92, 255, 0.04);
+  box-shadow:
+    0 10px 25px -5px rgba(31, 92, 255, 0.08),
+    0 8px 10px -6px rgba(31, 92, 255, 0.04);
   transform: translateY(-2px);
 }
 
diff --git a/docs/ppt/省心推-GEO完整路径.pptx b/docs/ppt/省心推-GEO完整路径.pptx
new file mode 100644
index 0000000..db15786
Binary files /dev/null and b/docs/ppt/省心推-GEO完整路径.pptx differ
diff --git a/docs/ppt/省心推-GEO技术原理.pptx b/docs/ppt/省心推-GEO技术原理.pptx
new file mode 100644
index 0000000..2d53be2
Binary files /dev/null and b/docs/ppt/省心推-GEO技术原理.pptx differ
diff --git a/docs/ppt/省心推-产品与团队介绍-已加水印.pptx b/docs/ppt/省心推-产品与团队介绍-已加水印.pptx
index 201e0c1..984ce4d 100644
Binary files a/docs/ppt/省心推-产品与团队介绍-已加水印.pptx and b/docs/ppt/省心推-产品与团队介绍-已加水印.pptx differ
diff --git a/docs/ppt/省心推-产品与团队介绍.pptx b/docs/ppt/省心推-产品与团队介绍.pptx
index 381c9cd..0b9e1d2 100644
Binary files a/docs/ppt/省心推-产品与团队介绍.pptx and b/docs/ppt/省心推-产品与团队介绍.pptx differ
diff --git a/docs/ppt/省心推-用户介绍资料.md b/docs/ppt/省心推-用户介绍资料.md
index d5fb287..e5753bf 100644
--- a/docs/ppt/省心推-用户介绍资料.md
+++ b/docs/ppt/省心推-用户介绍资料.md
@@ -1,105 +1,17 @@
-# 省心推 · 让品牌在 AI 时代被看见、被理解、被推荐
+# 跨境电商专项会议核心汇报
+本次会议完成团队标准化流程梳理、主流平台实操复盘及行业专家合作模式洽谈，核心成果与待决策事项如下：
 
-> 一句话介绍：**省心推是一款面向 AI 搜索与大模型问答场景的 GEO（生成式引擎优化）+ 智能发布平台，帮助企业把品牌内容做成 AI 愿意引用、愿意推荐的资产，并一键分发到全网。**
+## 一、团队体系梳理成果
+1. **搭建3岗业务闭环**：明确厂家对接、平台对接、双向统筹三大核心岗位，覆盖供应链到平台运营全链路，打通两端信息壁垒，保障业务高效协同。
+2. **划定四大业务板块**：锁定前端运营、客服服务、资金核算、货品对接核心模块，全面覆盖店铺日常运营场景。
 
----
+## 二、平台实操经验沉淀
+重点复盘Temu、希音两大跨境平台上货全流程，梳理形成平台上架规则、产品适配标准及流程优化方向，为后续精细化运营提供落地支撑。
 
-## 一、为什么现在要关注 GEO？
+## 三、专家合作方案（待决策）
+已与行业资深专家初步沟通两类合作模式，**报价均有协商空间，洽谈可兼顾性价比与合作诚意**：
+- **全职顾问模式**：月薪报价20000元，每周在岗2-3天，提供全流程落地指导、实操答疑、运营优化帮扶
+- **轻量咨询模式**：包月报价5000元，线上按需响应，提供业务流程梳理、运营方案输出、团队标准化搭建指导
 
-用户的搜索习惯正在发生根本性变化：
-
-- **以前**：用户打开百度、360、知乎，自己翻网页、比信息。
-- **现在**：越来越多的用户直接问 AI——豆包、DeepSeek、Kimi、文心一言、元宝、ChatGPT……AI 直接给出"答案"和"推荐"。
-
-这意味着一个关键转变：**竞争的战场从"搜索排名"转移到了"AI 答案"。**
-
-当客户问 AI"XX行业哪家公司靠谱"时，AI 的回答里有没有你的品牌、怎么介绍你的品牌，直接决定了客户会不会找到你。如果你的品牌信息没有被 AI 理解和收录，你在这个新入口上就是"隐形"的。
-
-**GEO（Generative Engine Optimization，生成式引擎优化）**，就是帮助品牌出现在 AI 回答、总结与推荐链路中的系统化方法——简单说：**让 AI 替你"全网搜索引流"，主动把你推荐给客户。**
-
----
-
-## 二、企业现在普遍的痛点
-
-| 痛点 | 现状 |
-| --- | --- |
-| 官网成"摆设" | 客户决策前先问 AI，官网流量持续下滑 |
-| 内容生产慢 | 写稿靠人工，产出慢、质量不稳定、品牌口径不统一 |
-| 多平台发布累 | 十几个平台逐个登录、复制粘贴，费时易错 |
-| AI 上"查无此人" | 问 AI 自家品牌，要么没有，要么信息陈旧甚至错误 |
-| 效果说不清 | 发了多少内容、AI 引用了没有、竞品表现如何，全靠感觉 |
-
-不是你缺渠道，而是**客户主动找你的场景变了**——省心推解决的，就是把流失在 AI 入口的客户找回来。
-
----
-
-## 三、省心推能为你做什么？
-
-省心推围绕"**内容生产 → 全网分发 → AI 监测 → 持续优化**"打造完整闭环：
-
-### 1. 品牌知识资产建设
-把品牌介绍、产品信息、常见问题、专业内容统一沉淀为结构化的品牌知识库，让内容生成有据可依、品牌口径全网一致——这也是 AI 能"读懂"你品牌的基础。
-
-### 2. AI 内容生成
-基于品牌知识库和行业模板，批量生成高质量、符合品牌调性的内容。围绕用户真实会问 AI 的问题来布局内容，精准触发 AI 推荐。
-
-### 3. 全网一键发布
-一次创作，多端分发。覆盖 **13 大主流媒体平台 + 企业官网站点**，无需逐个登录、复制粘贴，发布状态统一管理，大幅降低运营人力。
-
-### 4. AI 平台品牌监测
-持续追踪品牌在 **豆包、DeepSeek、Kimi 等 6 大主流 AI 平台**上的表现：你的品牌有没有被提及、被引用、被推荐，推荐语境是什么，和竞品比处于什么位置——让 GEO 效果看得见、可衡量。
-
-### 5. 数据回看与迭代
-发布数据、收录情况、AI 曝光趋势统一呈现，形成"发布 → 监测 → 优化"的迭代闭环，效果持续提升。
-
-### 6. 智能体（Agent）接入
-支持 MCP 协议，可与企业自有 AI 工作流和智能体打通，让发布与监测能力成为你 AI 化经营的一部分。
-
----
-
-## 四、用了省心推之后
-
-- **品牌更专业**：多平台持续输出统一、专业的品牌内容，客户一搜一问全是你。
-- **获客更主动**：客户问 AI 相关问题时，AI 主动推荐你，意向客户自己找上门。
-- **成交更省心**：客户来之前已经通过 AI 了解过你，信任前置，转化更快。
-- **运营更高效**：内容生成 + 一键分发 + 自动监测，原来一个团队的活，现在一个人就能干。
-
----
-
-## 五、适合谁用？
-
-- 希望在 AI 搜索时代抢占先机的**中小企业与品牌方**
-- 需要规模化内容生产与分发的**品牌运营 / 数字营销团队**
-- 为多个客户做品牌推广的**营销服务机构 / 工作室**
-
-适用行业：制造、电商、教育、医疗、法律、本地服务等需要被客户"搜到、问到、信到"的行业。
-
----
-
-## 六、关于我们
-
-我们是一支**AI 技术 × 全栈工程 × 质量评测**深度结合的创始团队，把对大模型的理解、产品工程化能力和效果评测体系装进同一个产品闭环。
-
-**梁旭** · 创始团队 / 技术负责人
-瑞典斯德哥尔摩大学人工智能硕士，曾任中科寒武纪全栈研发工程师。负责产品技术架构、核心功能研发与 AI 场景工程化落地。
-
-**宫磊** · 创始团队 / 质量与工程效能负责人
-中国科学技术大学硕士，曾在寒武纪、科大讯飞担任测试研发工程师。负责产品评测体系、稳定性保障与交付提效——确保 GEO 效果持续可衡量、可优化。
-
-**团队优势**：AI 理解力 → 产品工程化 → 效果评测 → 持续迭代。我们既懂大模型如何"理解和推荐"内容，也有把复杂 AI 产品稳定交付的硬科技企业一线经验。
-
----
-
-## 七、一分钟了解省心推
-
-> AI 革命已至，用户决策入口正在从搜索框迁移到 AI 对话框。
->
-> **省心推**帮你完成三件事：把品牌内容做成 AI 读得懂的资产；一键分发到全网媒体与官网；持续监测 AI 平台上的品牌表现。
->
-> 当你的同行还在盲目投放、原地观望时，先布局的品牌已经成为 AI 答案里的"标准推荐"。
->
-> **这一次，别让品牌在 AI 时代隐身。**
-
----
-
-*欢迎联系我们获取产品演示与试用。*
+## 后续建议
+可结合团队当前运营阶段与预算选定适配模式：若需快速跑通业务、手把手带教团队，可优先推进全职顾问模式洽谈；若仅需方向把控与阶段性问题指导，可选择轻量咨询模式，加速团队标准化落地与业务起量。
\ No newline at end of file
diff --git a/packages/shared-types/src/index.ts b/packages/shared-types/src/index.ts
index bb4088a..5201d4d 100644
--- a/packages/shared-types/src/index.ts
+++ b/packages/shared-types/src/index.ts
@@ -1895,9 +1895,12 @@ export interface MonitoringCitationRankingItem {
 }
 
 export interface MonitoringCitedArticle {
-  article_id: number
+  article_id: number | null
   article_title: string
   publish_platform: string
+  source_type: string
+  source_id: number
+  source_url: string
   citation_count: number
   citation_rate: number | null
   source_share: number | null
@@ -1954,6 +1957,9 @@ export interface MonitoringQuestionDetailCitation {
   site_key: string
   favicon_url: string
   article_id: number | null
+  source_type?: string | null
+  source_id?: number | null
+  source_url?: string | null
   article_title?: string | null
   resolution_status: string
   resolution_confidence: string
@@ -1985,15 +1991,46 @@ export interface MonitoringQuestionCitationAnalysisItem {
 }
 
 export interface MonitoringQuestionContentCitation {
-  article_id: number
+  article_id: number | null
   article_title: string
   publish_platform: string
+  source_type: string
+  source_id: number
+  source_url: string
   ai_platform_id: string
   platform_name: string
   citation_count: number
   citation_rate: number | null
 }
 
+export interface MonitoringMarkedArticle {
+  id: number
+  brand_id: number | null
+  article_title: string
+  original_url: string
+  normalized_url: string
+  host: string
+  registrable_domain: string
+  site_key: string
+  publish_platform: string
+  marked_by_user_id: number | null
+  marked_at: string
+  expires_at: string
+  created_at: string
+  updated_at: string
+}
+
+export interface MonitoringMarkedArticleListResponse {
+  items: MonitoringMarkedArticle[]
+  page: MonitoringPage
+}
+
+export interface MonitoringMarkedArticleRequest {
+  article_title: string
+  original_url: string
+  brand_id?: number | null
+}
+
 export interface MonitoringQuestionDetailResponse {
   question_id: number
   question_hash: string
diff --git a/server/internal/scheduler/monitoring_retention_worker.go b/server/internal/scheduler/monitoring_retention_worker.go
index 8cd259c..078fe70 100644
--- a/server/internal/scheduler/monitoring_retention_worker.go
+++ b/server/internal/scheduler/monitoring_retention_worker.go
@@ -22,9 +22,10 @@ type MonitoringRetentionWorker struct {
 }
 
 type retentionTarget struct {
-	Name      string
-	DeleteSQL string
-	ProbeSQL  string
+	Name         string
+	DeleteSQL    string
+	ProbeSQL     string
+	PreDeleteSQL string
 }
 
 func NewMonitoringRetentionWorker(monitoringPool *pgxpool.Pool, logger *zap.Logger) *MonitoringRetentionWorker {
@@ -136,11 +137,10 @@ func (w *MonitoringRetentionWorker) deleteTarget(ctx context.Context, conn *pgxp
 	total := int64(0)
 	batches := 0
 	for batches < maxBatches {
-		tag, err := conn.Exec(ctx, target.DeleteSQL, cutoffDate, batchSize)
+		affected, err := w.deleteTargetBatch(ctx, conn, target, cutoffDate, batchSize)
 		if err != nil {
 			return total, batches, err
 		}
-		affected := tag.RowsAffected()
 		if affected == 0 {
 			break
 		}
@@ -153,6 +153,40 @@ func (w *MonitoringRetentionWorker) deleteTarget(ctx context.Context, conn *pgxp
 	return total, batches, nil
 }
 
+func (w *MonitoringRetentionWorker) deleteTargetBatch(ctx context.Context, conn *pgxpool.Conn, target retentionTarget, cutoffDate string, batchSize int) (int64, error) {
+	if strings.TrimSpace(target.PreDeleteSQL) == "" {
+		tag, err := conn.Exec(ctx, target.DeleteSQL, cutoffDate, batchSize)
+		if err != nil {
+			return 0, err
+		}
+		return tag.RowsAffected(), nil
+	}
+
+	tx, err := conn.Begin(ctx)
+	if err != nil {
+		return 0, fmt.Errorf("begin delete batch: %w", err)
+	}
+	committed := false
+	defer func() {
+		if !committed {
+			_ = tx.Rollback(context.Background())
+		}
+	}()
+
+	if _, err := tx.Exec(ctx, target.PreDeleteSQL, cutoffDate, batchSize); err != nil {
+		return 0, fmt.Errorf("pre-delete batch: %w", err)
+	}
+	tag, err := tx.Exec(ctx, target.DeleteSQL, cutoffDate, batchSize)
+	if err != nil {
+		return 0, err
+	}
+	if err := tx.Commit(ctx); err != nil {
+		return 0, fmt.Errorf("commit delete batch: %w", err)
+	}
+	committed = true
+	return tag.RowsAffected(), nil
+}
+
 func retentionTargets() []retentionTarget {
 	return []retentionTarget{
 		{
@@ -190,6 +224,12 @@ func retentionTargets() []retentionTarget {
 			ProbeSQL:  batchProbeSQL("question_monitor_runs", "id", "business_date < $1::date", "business_date ASC, id ASC"),
 			DeleteSQL: batchDeleteSQL("question_monitor_runs", "id", "business_date < $1::date", "business_date ASC, id ASC"),
 		},
+		{
+			Name:         "monitoring_user_marked_articles",
+			ProbeSQL:     batchProbeSQL("monitoring_user_marked_articles", "id", "$1::date IS NOT NULL AND expires_at < NOW()", "expires_at ASC, id ASC"),
+			PreDeleteSQL: markedArticleAttributionCleanupSQL(),
+			DeleteSQL:    batchDeleteSQL("monitoring_user_marked_articles", "id", "$1::date IS NOT NULL AND expires_at < NOW()", "expires_at ASC, id ASC"),
+		},
 	}
 }
 
@@ -223,3 +263,24 @@ func batchDeleteSQL(table, idColumn, predicate, orderBy string) string {
 	}
 	return strings.Join(parts, "\n")
 }
+
+func markedArticleAttributionCleanupSQL() string {
+	parts := []string{
+		"WITH doomed AS (",
+		"SELECT tenant_id, id",
+		"FROM monitoring_user_marked_articles",
+		"WHERE $1::date IS NOT NULL AND expires_at < NOW()",
+		"ORDER BY expires_at ASC, id ASC",
+		"LIMIT $2",
+		"FOR UPDATE SKIP LOCKED",
+		")",
+		"UPDATE monitoring_citation_facts cf",
+		"SET content_source_type = NULL,",
+		"    content_source_id = NULL",
+		"FROM doomed",
+		"WHERE cf.tenant_id = doomed.tenant_id",
+		"  AND cf.content_source_type = 'manual_mark'",
+		"  AND cf.content_source_id = doomed.id",
+	}
+	return strings.Join(parts, "\n")
+}
diff --git a/server/internal/scheduler/monitoring_retention_worker_test.go b/server/internal/scheduler/monitoring_retention_worker_test.go
index 4891d4b..be14de2 100644
--- a/server/internal/scheduler/monitoring_retention_worker_test.go
+++ b/server/internal/scheduler/monitoring_retention_worker_test.go
@@ -34,3 +34,34 @@ func TestBatchProbeSQLCapsDryRunProbe(t *testing.T) {
 		t.Fatalf("batchProbeSQL should count only the limited candidate subquery:\n%s", sql)
 	}
 }
+
+func TestMarkedArticleRetentionClearsManualAttributionBeforeDelete(t *testing.T) {
+	var target retentionTarget
+	for _, item := range retentionTargets() {
+		if item.Name == "monitoring_user_marked_articles" {
+			target = item
+			break
+		}
+	}
+	if target.Name == "" {
+		t.Fatal("monitoring_user_marked_articles retention target missing")
+	}
+	if target.PreDeleteSQL == "" {
+		t.Fatal("monitoring_user_marked_articles retention target must clear citation attribution before delete")
+	}
+
+	for _, want := range []string{
+		"SELECT tenant_id, id",
+		"UPDATE monitoring_citation_facts cf",
+		"cf.tenant_id = doomed.tenant_id",
+		"content_source_type = 'manual_mark'",
+		"content_source_id = doomed.id",
+		"SET content_source_type = NULL",
+		"LIMIT $2",
+		"FOR UPDATE SKIP LOCKED",
+	} {
+		if !strings.Contains(target.PreDeleteSQL, want) {
+			t.Fatalf("marked article attribution cleanup SQL missing %q in SQL:\n%s", want, target.PreDeleteSQL)
+		}
+	}
+}
diff --git a/server/internal/shared/swagger/descriptions.go b/server/internal/shared/swagger/descriptions.go
index d3a6d72..7f5ef84 100644
--- a/server/internal/shared/swagger/descriptions.go
+++ b/server/internal/shared/swagger/descriptions.go
@@ -351,6 +351,10 @@ var routeDocs = map[string]routeDoc{
 	// --- Tenant：监控（GEO 仪表盘） ---
 	"GET /api/tenant/monitoring/dashboard/composite":                            {"监控仪表盘综合视图", "组合返回品牌曝光、引用率、问答覆盖等监控指标。"},
 	"GET /api/tenant/monitoring/citation-summary":                               {"引用情况汇总", "按 AI 平台维度返回品牌的引用频次与变化。"},
+	"GET /api/tenant/monitoring/marked-articles":                                {"外部文章标记列表", "分页查询用户手动标记的外部文章，可按域名、文章名称和时间范围过滤。"},
+	"POST /api/tenant/monitoring/marked-articles":                               {"标记外部文章", "将无法自动对接的外部 URL 标记为外部文章，用于引用归因与排行。"},
+	"PUT /api/tenant/monitoring/marked-articles/:id":                            {"更新外部文章标记", "更新外部文章标记的文章名称、原始 URL 或关联品牌。"},
+	"DELETE /api/tenant/monitoring/marked-articles/:id":                         {"删除外部文章标记", "删除一条用户手动标记的外部文章记录。"},
 	"GET /api/tenant/monitoring/brands/:brand_id/questions/:question_id/detail": {"问题级监控详情", "某问题在各 AI 平台的回答样本与引用拆解。"},
 	"POST /api/tenant/monitoring/brands/:brand_id/collect-now":                  {"立即触发采集", "对某品牌立即下发一次监控采集任务，跳过定时计划。"},
 
diff --git a/server/internal/shared/swagger/swagger.go b/server/internal/shared/swagger/swagger.go
index e6d8753..654b678 100644
--- a/server/internal/shared/swagger/swagger.go
+++ b/server/internal/shared/swagger/swagger.go
@@ -334,6 +334,8 @@ func queryParameterNames(route gin.RouteInfo) []string {
 		add("brand_id", "keyword_id", "question_id", "days", "business_date", "ai_platform_id")
 	case strings.Contains(path, "/tenant/monitoring/citation-summary"):
 		add("days", "brand_id", "keyword_id", "question_id", "business_date", "ai_platform_id")
+	case strings.Contains(path, "/tenant/monitoring/marked-articles"):
+		add("page", "page_size", "domain", "title", "created_from", "created_to")
 	case strings.Contains(path, "/tenant/monitoring/brands/"):
 		add("ai_platform_id", "date_from", "date_to", "question_hash")
 	case strings.Contains(path, "/tenant/kol/marketplace/packages"):
diff --git a/server/internal/tenant/app/brand_service.go b/server/internal/tenant/app/brand_service.go
index e11c392..84b4b57 100644
--- a/server/internal/tenant/app/brand_service.go
+++ b/server/internal/tenant/app/brand_service.go
@@ -96,6 +96,20 @@ type BrandLibrarySummaryResponse struct {
 	MaxQuestionsPerBrand   int    `json:"max_questions_per_brand"`
 }
 
+func formatBrandTime(value interface{}) string {
+	switch typed := value.(type) {
+	case time.Time:
+		return typed.UTC().Format(time.RFC3339Nano)
+	case *time.Time:
+		if typed == nil {
+			return ""
+		}
+		return typed.UTC().Format(time.RFC3339Nano)
+	default:
+		return fmt.Sprintf("%v", value)
+	}
+}
+
 func (s *BrandService) List(ctx context.Context) ([]BrandResponse, error) {
 	actor := auth.MustActor(ctx)
 	brands, err := sharedcache.LoadJSON(ctx, s.cache, &s.cacheGroup, brandListCacheKey(actor.TenantID), defaultCacheTTL(), func(loadCtx context.Context) ([]BrandResponse, error) {
@@ -197,7 +211,7 @@ func (s *BrandService) Create(ctx context.Context, req BrandRequest) (*BrandResp
 		KeywordCount:    0,
 		QuestionCount:   0,
 		CompetitorCount: 0,
-		CreatedAt:       fmt.Sprintf("%v", ca),
+		CreatedAt:       formatBrandTime(ca),
 	}, nil
 }
 
@@ -367,7 +381,7 @@ func (s *BrandService) CreateKeyword(ctx context.Context, brandID int64, req Key
 		return nil, response.ErrInternal(50010, "create_failed", "failed to create keyword")
 	}
 	invalidateBrandCaches(ctx, s.cache, actor.TenantID, brandID)
-	return &KeywordResponse{ID: id, BrandID: brandID, Name: req.Name, Status: "active", CreatedAt: fmt.Sprintf("%v", ca)}, nil
+	return &KeywordResponse{ID: id, BrandID: brandID, Name: req.Name, Status: "active", CreatedAt: formatBrandTime(ca)}, nil
 }
 
 func (s *BrandService) UpdateKeyword(ctx context.Context, brandID, keywordID int64, req KeywordRequest) error {
@@ -587,7 +601,7 @@ func (s *BrandService) CreateQuestion(ctx context.Context, brandID int64, req Qu
 		KeywordID:    req.KeywordID,
 		QuestionText: req.QuestionText,
 		Status:       "active",
-		CreatedAt:    fmt.Sprintf("%v", ca),
+		CreatedAt:    formatBrandTime(ca),
 	}, nil
 }
 
@@ -718,7 +732,7 @@ func (s *BrandService) CreateCompetitor(ctx context.Context, brandID int64, req
 		return nil, response.ErrInternal(50010, "create_failed", "failed to create competitor")
 	}
 	invalidateBrandCaches(ctx, s.cache, actor.TenantID, brandID)
-	return &CompetitorResponse{ID: id, BrandID: brandID, Name: req.Name, Website: req.Website, Description: req.Description, ProductLinesJSON: req.ProductLinesJSON, CreatedAt: fmt.Sprintf("%v", ca)}, nil
+	return &CompetitorResponse{ID: id, BrandID: brandID, Name: req.Name, Website: req.Website, Description: req.Description, ProductLinesJSON: req.ProductLinesJSON, CreatedAt: formatBrandTime(ca)}, nil
 }
 
 func (s *BrandService) UpdateCompetitor(ctx context.Context, brandID, competitorID int64, req CompetitorRequest) error {
@@ -804,8 +818,8 @@ func (s *BrandService) loadBrands(ctx context.Context, tenantID int64) ([]BrandR
 		if err := rows.Scan(&item.ID, &item.Name, &item.Website, &item.Description, &item.Status, &item.KeywordCount, &item.QuestionCount, &item.CompetitorCount, &createdAt, &updatedAt); err != nil {
 			return nil, response.ErrInternal(50010, "scan_failed", err.Error())
 		}
-		item.CreatedAt = fmt.Sprintf("%v", createdAt)
-		item.UpdatedAt = fmt.Sprintf("%v", updatedAt)
+		item.CreatedAt = formatBrandTime(createdAt)
+		item.UpdatedAt = formatBrandTime(updatedAt)
 		brands = append(brands, item)
 	}
 	return brands, nil
@@ -859,8 +873,8 @@ func (s *BrandService) loadBrandDetail(ctx context.Context, tenantID, brandID in
 		}
 		return nil, false, response.ErrInternal(50010, "query_failed", "failed to fetch brand")
 	}
-	item.CreatedAt = fmt.Sprintf("%v", createdAt)
-	item.UpdatedAt = fmt.Sprintf("%v", updatedAt)
+	item.CreatedAt = formatBrandTime(createdAt)
+	item.UpdatedAt = formatBrandTime(updatedAt)
 	return &item, true, nil
 }
 
@@ -885,7 +899,7 @@ func (s *BrandService) loadBrandKeywords(ctx context.Context, tenantID, brandID
 		if err := rows.Scan(&item.ID, &item.BrandID, &item.Name, &item.Status, &createdAt); err != nil {
 			return nil, response.ErrInternal(50010, "scan_failed", err.Error())
 		}
-		item.CreatedAt = fmt.Sprintf("%v", createdAt)
+		item.CreatedAt = formatBrandTime(createdAt)
 		items = append(items, item)
 	}
 	return items, nil
@@ -943,7 +957,7 @@ func (s *BrandService) loadBrandQuestions(ctx context.Context, tenantID, brandID
 		if err := rows.Scan(&item.ID, &item.BrandID, &item.KeywordID, &item.QuestionText, &item.Status, &createdAt); err != nil {
 			return nil, response.ErrInternal(50010, "scan_failed", err.Error())
 		}
-		item.CreatedAt = fmt.Sprintf("%v", createdAt)
+		item.CreatedAt = formatBrandTime(createdAt)
 		items = append(items, item)
 	}
 	if err := rows.Err(); err != nil {
@@ -978,7 +992,7 @@ func (s *BrandService) loadBrandCompetitors(ctx context.Context, tenantID, brand
 		if err := rows.Scan(&item.ID, &item.BrandID, &item.Name, &item.Website, &item.Description, &productLinesJSON, &createdAt); err != nil {
 			return nil, response.ErrInternal(50010, "scan_failed", err.Error())
 		}
-		item.CreatedAt = fmt.Sprintf("%v", createdAt)
+		item.CreatedAt = formatBrandTime(createdAt)
 		if productLinesJSON != nil {
 			raw := json.RawMessage(productLinesJSON)
 			item.ProductLinesJSON = &raw
diff --git a/server/internal/tenant/app/brand_service_time_test.go b/server/internal/tenant/app/brand_service_time_test.go
new file mode 100644
index 0000000..2f28d85
--- /dev/null
+++ b/server/internal/tenant/app/brand_service_time_test.go
@@ -0,0 +1,18 @@
+package app
+
+import (
+	"testing"
+	"time"
+)
+
+func TestFormatBrandTimeUsesRFC3339UTC(t *testing.T) {
+	loc := time.FixedZone("CST", 8*60*60)
+	value := time.Date(2026, 6, 17, 10, 52, 1, 307551000, loc)
+
+	got := formatBrandTime(value)
+	want := "2026-06-17T02:52:01.307551Z"
+
+	if got != want {
+		t.Fatalf("formatBrandTime() = %q, want %q", got, want)
+	}
+}
diff --git a/server/internal/tenant/app/monitoring_article_alias_sync.go b/server/internal/tenant/app/monitoring_article_alias_sync.go
index 811c4a3..4f9fdaa 100644
--- a/server/internal/tenant/app/monitoring_article_alias_sync.go
+++ b/server/internal/tenant/app/monitoring_article_alias_sync.go
@@ -72,6 +72,24 @@ func (s *DesktopTaskService) syncMonitoringArticleAlias(ctx context.Context, inp
 		nullableString(lastPathSegment),
 		confidence,
 	)
+	if err != nil {
+		return err
+	}
+	if confidence == "high" {
+		_, err = s.monitoringPool.Exec(ctx, `
+			UPDATE monitoring_citation_facts
+			SET content_source_type = 'published_article',
+			    content_source_id = $3,
+			    article_id = COALESCE(article_id, $3),
+			    publish_record_id = COALESCE(publish_record_id, $4)
+			WHERE tenant_id = $1
+			  AND normalized_url = $2
+			  AND (
+			    content_source_type IS DISTINCT FROM 'published_article'
+			    OR content_source_id IS DISTINCT FROM $3
+			  )
+		`, input.TenantID, normalizedURL, input.ArticleID, input.PublishRecordID)
+	}
 	return err
 }
 
diff --git a/server/internal/tenant/app/monitoring_callback_service.go b/server/internal/tenant/app/monitoring_callback_service.go
index 0f43eae..20a5ca3 100644
--- a/server/internal/tenant/app/monitoring_callback_service.go
+++ b/server/internal/tenant/app/monitoring_callback_service.go
@@ -279,6 +279,8 @@ type monitoringAliasResolution struct {
 	ArticleID            *int64
 	PublishRecordID      *int64
 	NormalizedURLKey     string
+	SourceType           string
+	SourceID             *int64
 	ResolutionStatus     string
 	ResolutionConfidence string
 }
@@ -298,6 +300,9 @@ type monitoringAliasCandidate struct {
 	MatchKeys         []string
 	ArticleID         *int64
 	PublishRecordID   *int64
+	SourceType        string
+	SourceID          *int64
+	SourcePriority    int
 	RegistrableDomain string
 	SiteKey           string
 	Host              string
@@ -316,6 +321,8 @@ type monitoringCitationFact struct {
 	SiteKey              string
 	ArticleID            *int64
 	PublishRecordID      *int64
+	ContentSourceType    *string
+	ContentSourceID      *int64
 	ResolutionStatus     string
 	ResolutionConfidence string
 }
@@ -2119,7 +2126,7 @@ func (s *MonitoringCallbackService) processTaskResult(ctx context.Context, task
 				return nil, err
 			}
 			citationSourceCount++
-			if fact.ArticleID != nil {
+			if fact.ContentSourceType != nil && fact.ContentSourceID != nil {
 				contentCitationCount++
 			}
 		}
@@ -2591,23 +2598,61 @@ func (s *MonitoringCallbackService) loadAliasResolutions(ctx context.Context, tx
 	}
 
 	rows, err := tx.Query(ctx, `
+		WITH alias_sources AS (
+			SELECT
+				normalized_url,
+				article_id,
+				publish_record_id,
+					'published_article' AS source_type,
+					article_id AS source_id,
+					1 AS source_priority,
+					registrable_domain,
+				site_key,
+				host,
+				last_path_segment,
+				article_title_snapshot,
+				updated_at,
+				id
+			FROM monitoring_article_url_aliases
+			WHERE tenant_id = $1
+			  AND confidence = 'high'
+			UNION ALL
+			SELECT
+				normalized_url,
+				NULL AS article_id,
+				NULL AS publish_record_id,
+					'manual_mark' AS source_type,
+					id AS source_id,
+					2 AS source_priority,
+					registrable_domain,
+				site_key,
+				host,
+				last_path_segment,
+				article_title AS article_title_snapshot,
+				updated_at,
+				id
+			FROM monitoring_user_marked_articles
+			WHERE tenant_id = $1
+			  AND expires_at > NOW()
+		)
 		SELECT
 			normalized_url,
 			article_id,
 			publish_record_id,
-			registrable_domain,
+				source_type,
+				source_id,
+				source_priority,
+				registrable_domain,
 			site_key,
 			host,
 			last_path_segment,
 			article_title_snapshot
-		FROM monitoring_article_url_aliases
-		WHERE tenant_id = $1
-		  AND (
-			normalized_url = ANY($2::text[])
-			OR NULLIF(LOWER(TRIM(registrable_domain)), '') = ANY($3::text[])
-			OR NULLIF(LOWER(TRIM(site_key)), '') = ANY($3::text[])
-			OR NULLIF(LOWER(TRIM(host)), '') = ANY($3::text[])
-		  )
+		FROM alias_sources
+		WHERE normalized_url = ANY($2::text[])
+		   OR NULLIF(LOWER(TRIM(registrable_domain)), '') = ANY($3::text[])
+		   OR NULLIF(LOWER(TRIM(site_key)), '') = ANY($3::text[])
+		   OR NULLIF(LOWER(TRIM(host)), '') = ANY($3::text[])
+		ORDER BY updated_at DESC, id DESC
 	`, tenantID, normalizedURLs, domainKeys)
 	if err != nil {
 		return nil, response.ErrInternal(50041, "alias_lookup_failed", "failed to resolve article aliases")
@@ -2619,6 +2664,7 @@ func (s *MonitoringCallbackService) loadAliasResolutions(ctx context.Context, tx
 		var candidate monitoringAliasCandidate
 		var articleID sql.NullInt64
 		var publishRecordID sql.NullInt64
+		var sourceID sql.NullInt64
 		var registrableDomain sql.NullString
 		var siteKey sql.NullString
 		var host sql.NullString
@@ -2628,6 +2674,9 @@ func (s *MonitoringCallbackService) loadAliasResolutions(ctx context.Context, tx
 			&candidate.NormalizedURL,
 			&articleID,
 			&publishRecordID,
+			&candidate.SourceType,
+			&sourceID,
+			&candidate.SourcePriority,
 			&registrableDomain,
 			&siteKey,
 			&host,
@@ -2638,6 +2687,7 @@ func (s *MonitoringCallbackService) loadAliasResolutions(ctx context.Context, tx
 		}
 		candidate.ArticleID = nullableInt64Value(articleID)
 		candidate.PublishRecordID = nullableInt64Value(publishRecordID)
+		candidate.SourceID = nullableInt64Value(sourceID)
 		candidate.RegistrableDomain = strings.ToLower(strings.TrimSpace(nullableStringText(registrableDomain)))
 		candidate.SiteKey = strings.ToLower(strings.TrimSpace(nullableStringText(siteKey)))
 		candidate.Host = strings.ToLower(strings.TrimSpace(nullableStringText(host)))
@@ -2665,8 +2715,14 @@ func (s *MonitoringCallbackService) loadAliasResolutions(ctx context.Context, tx
 				best = candidate
 				continue
 			}
-			if score == bestScore && !sameInt64Pointer(candidate.ArticleID, best.ArticleID) {
-				bestAmbiguous = true
+			if score == bestScore && !sameMonitoringAliasCandidateSource(candidate, best) {
+				if best.SourcePriority == 0 || candidate.SourcePriority == best.SourcePriority {
+					bestAmbiguous = true
+				}
+				if best.SourcePriority == 0 || (candidate.SourcePriority > 0 && candidate.SourcePriority < best.SourcePriority) {
+					bestAmbiguous = false
+					best = candidate
+				}
 			}
 		}
 
@@ -2677,6 +2733,8 @@ func (s *MonitoringCallbackService) loadAliasResolutions(ctx context.Context, tx
 			ArticleID:            cloneInt64(best.ArticleID),
 			PublishRecordID:      cloneInt64(best.PublishRecordID),
 			NormalizedURLKey:     best.NormalizedURL,
+			SourceType:           strings.TrimSpace(best.SourceType),
+			SourceID:             cloneInt64(best.SourceID),
 			ResolutionStatus:     "resolved",
 			ResolutionConfidence: "high",
 		}
@@ -2745,19 +2803,28 @@ func sameInt64Pointer(left, right *int64) bool {
 	return *left == *right
 }
 
+func sameMonitoringAliasCandidateSource(left, right monitoringAliasCandidate) bool {
+	leftType := strings.TrimSpace(left.SourceType)
+	rightType := strings.TrimSpace(right.SourceType)
+	if leftType == "" && rightType == "" {
+		return sameInt64Pointer(left.ArticleID, right.ArticleID)
+	}
+	return leftType == rightType && sameInt64Pointer(left.SourceID, right.SourceID)
+}
+
 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
+			content_source_type, content_source_id, resolution_status, resolution_confidence
 		)
 		VALUES (
 			$1, $2, $3, $4, $5::date,
 			$6, $7, $8, $9, $10,
 			$11, $12, $13, $14, $15,
-			$16, $17
+			$16, $17, $18, $19
 		)
 	`,
 		task.TenantID,
@@ -2775,6 +2842,8 @@ func (s *MonitoringCallbackService) insertCitationFact(ctx context.Context, tx p
 		fact.SiteKey,
 		nullableInt64(fact.ArticleID),
 		nullableInt64(fact.PublishRecordID),
+		nullableString(fact.ContentSourceType),
+		nullableInt64(fact.ContentSourceID),
 		fact.ResolutionStatus,
 		fact.ResolutionConfidence,
 	); err != nil {
@@ -2926,10 +2995,10 @@ func (s *MonitoringCallbackService) loadExistingRunSummary(ctx context.Context,
 	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 AND $3::text <> 'qwen')::int AS content_citation_count
-		FROM monitoring_citation_facts
+			SELECT
+				COUNT(*)::int AS citation_source_count,
+				COUNT(*) FILTER (WHERE content_source_type IS NOT NULL AND content_source_id IS NOT NULL AND $3::text <> 'qwen')::int AS content_citation_count
+			FROM monitoring_citation_facts
 		WHERE tenant_id = $1
 		  AND run_id = $2
 	`, task.TenantID, runID.Int64, normalizeMonitoringPlatformID(task.AIPlatformID)).Scan(&citationSourceCount, &contentCitationCount); err != nil {
@@ -3173,6 +3242,8 @@ func buildMonitoringCitationFact(input MonitoringSourceItem, aliasMap map[string
 
 	var articleID *int64
 	var publishRecordID *int64
+	var contentSourceType *string
+	var contentSourceID *int64
 	var aliasResolution *monitoringAliasResolution
 	if resolveContentCitations {
 		articleID = cloneInt64(input.ArticleID)
@@ -3186,6 +3257,10 @@ func buildMonitoringCitationFact(input MonitoringSourceItem, aliasMap map[string
 			if publishRecordID == nil {
 				publishRecordID = cloneInt64(alias.PublishRecordID)
 			}
+			if strings.TrimSpace(alias.SourceType) != "" && alias.SourceID != nil {
+				contentSourceType = optionalString(strings.TrimSpace(alias.SourceType))
+				contentSourceID = cloneInt64(alias.SourceID)
+			}
 		}
 	}
 
@@ -3217,6 +3292,8 @@ func buildMonitoringCitationFact(input MonitoringSourceItem, aliasMap map[string
 		SiteKey:              siteKey,
 		ArticleID:            articleID,
 		PublishRecordID:      publishRecordID,
+		ContentSourceType:    contentSourceType,
+		ContentSourceID:      contentSourceID,
 		ResolutionStatus:     resolutionStatus,
 		ResolutionConfidence: resolutionConfidence,
 	}, true
diff --git a/server/internal/tenant/app/monitoring_citation_match.go b/server/internal/tenant/app/monitoring_citation_match.go
index 2570125..330f613 100644
--- a/server/internal/tenant/app/monitoring_citation_match.go
+++ b/server/internal/tenant/app/monitoring_citation_match.go
@@ -18,6 +18,11 @@ type monitoringPublishedAlias struct {
 	PublishRecordID *int64
 	ArticleTitle    string
 	PublishPlatform string
+	OriginalURL     string
+	NormalizedURL   string
+	SourceType      string
+	SourceID        int64
+	SourcePriority  int
 	Ambiguous       bool
 }
 
@@ -29,17 +34,51 @@ type monitoringAliasQuerier interface {
 
 func loadMonitoringPublishedAliasIndex(ctx context.Context, q monitoringAliasQuerier, tenantID int64) (monitoringPublishedAliasIndex, error) {
 	rows, err := q.Query(ctx, `
+		WITH alias_sources AS (
+			SELECT
+				article_id,
+				publish_record_id,
+				COALESCE(article_title_snapshot, '未命名文章') AS article_title,
+				COALESCE(publish_platform_name_snapshot, '已发布内容') AS publish_platform,
+				original_url,
+				normalized_url,
+					'published_article' AS source_type,
+					article_id AS source_id,
+					1 AS source_priority,
+					updated_at AS sort_updated_at,
+					id AS sort_id
+			FROM monitoring_article_url_aliases
+			WHERE tenant_id = $1
+			  AND confidence = 'high'
+			UNION ALL
+			SELECT
+				NULL AS article_id,
+				NULL AS publish_record_id,
+				COALESCE(NULLIF(article_title, ''), '未命名文章') AS article_title,
+				COALESCE(NULLIF(publish_platform, ''), '外部文章') AS publish_platform,
+				original_url,
+				normalized_url,
+					'manual_mark' AS source_type,
+					id AS source_id,
+					2 AS source_priority,
+					updated_at AS sort_updated_at,
+					id AS sort_id
+			FROM monitoring_user_marked_articles
+			WHERE tenant_id = $1
+			  AND expires_at > NOW()
+		)
 		SELECT
 			article_id,
 			publish_record_id,
-			COALESCE(article_title_snapshot, '未命名文章') AS article_title,
-			COALESCE(publish_platform_name_snapshot, '已发布内容') AS publish_platform,
+			article_title,
+			publish_platform,
 			original_url,
-			normalized_url
-		FROM monitoring_article_url_aliases
-		WHERE tenant_id = $1
-		  AND confidence = 'high'
-		ORDER BY updated_at DESC, id DESC
+			normalized_url,
+				source_type,
+				source_id,
+				source_priority
+			FROM alias_sources
+			ORDER BY source_priority ASC, sort_updated_at DESC, sort_id DESC
 	`, tenantID)
 	if err != nil {
 		return nil, responseInternalAliasLookupError()
@@ -52,13 +91,36 @@ func loadMonitoringPublishedAliasIndex(ctx context.Context, q monitoringAliasQue
 		var originalURL string
 		var normalizedURL string
 		var publishRecordID sql.NullInt64
-		if scanErr := rows.Scan(&item.ArticleID, &publishRecordID, &item.ArticleTitle, &item.PublishPlatform, &originalURL, &normalizedURL); scanErr != nil {
+		var articleID sql.NullInt64
+		if scanErr := rows.Scan(
+			&articleID,
+			&publishRecordID,
+			&item.ArticleTitle,
+			&item.PublishPlatform,
+			&originalURL,
+			&normalizedURL,
+			&item.SourceType,
+			&item.SourceID,
+			&item.SourcePriority,
+		); scanErr != nil {
 			return nil, responseInternalAliasScanError()
 		}
+		if articleID.Valid {
+			item.ArticleID = articleID.Int64
+		}
 		item.PublishRecordID = nullableInt64Value(publishRecordID)
+		item.OriginalURL = originalURL
+		item.NormalizedURL = normalizedURL
 		for _, key := range monitoringCitationCandidateKeys(originalURL, normalizedURL) {
 			existing, exists := index[key]
-			if exists && existing.ArticleID != item.ArticleID {
+			if exists && existing.SourcePriority < item.SourcePriority {
+				continue
+			}
+			if exists && item.SourcePriority < existing.SourcePriority {
+				index[key] = item
+				continue
+			}
+			if exists && (existing.SourceType != item.SourceType || existing.SourceID != item.SourceID) {
 				existing.Ambiguous = true
 				index[key] = existing
 				continue
diff --git a/server/internal/tenant/app/monitoring_marked_article_service.go b/server/internal/tenant/app/monitoring_marked_article_service.go
new file mode 100644
index 0000000..079a88d
--- /dev/null
+++ b/server/internal/tenant/app/monitoring_marked_article_service.go
@@ -0,0 +1,522 @@
+package app
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"net/url"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/jackc/pgx/v5"
+
+	"github.com/geo-platform/tenant-api/internal/shared/auth"
+	"github.com/geo-platform/tenant-api/internal/shared/response"
+)
+
+type MonitoringMarkedArticleListParams struct {
+	Domain      string
+	Title       string
+	CreatedFrom string
+	CreatedTo   string
+	Page        int
+	PageSize    int
+}
+
+type MonitoringMarkedArticleRequest struct {
+	ArticleTitle string `json:"article_title"`
+	OriginalURL  string `json:"original_url"`
+	BrandID      *int64 `json:"brand_id"`
+}
+
+type MonitoringMarkedArticle struct {
+	ID                int64  `json:"id"`
+	BrandID           *int64 `json:"brand_id"`
+	ArticleTitle      string `json:"article_title"`
+	OriginalURL       string `json:"original_url"`
+	NormalizedURL     string `json:"normalized_url"`
+	Host              string `json:"host"`
+	RegistrableDomain string `json:"registrable_domain"`
+	SiteKey           string `json:"site_key"`
+	PublishPlatform   string `json:"publish_platform"`
+	MarkedByUserID    *int64 `json:"marked_by_user_id"`
+	MarkedAt          string `json:"marked_at"`
+	ExpiresAt         string `json:"expires_at"`
+	CreatedAt         string `json:"created_at"`
+	UpdatedAt         string `json:"updated_at"`
+}
+
+type MonitoringMarkedArticleListResponse struct {
+	Items []MonitoringMarkedArticle `json:"items"`
+	Page  MonitoringPage            `json:"page"`
+}
+
+type monitoringMarkedArticleURLMeta struct {
+	OriginalURL       string
+	NormalizedURL     string
+	Host              string
+	RegistrableDomain string
+	SiteKey           string
+	LastPathSegment   *string
+}
+
+func (s *MonitoringService) ListMarkedArticles(ctx context.Context, params MonitoringMarkedArticleListParams) (*MonitoringMarkedArticleListResponse, error) {
+	actor := auth.MustActor(ctx)
+	pageReq := normalizeMonitoringPageRequest(MonitoringPageRequest{
+		Page:     params.Page,
+		PageSize: params.PageSize,
+	}, defaultMonitoringListPageSize)
+
+	createdFrom, createdTo, err := parseMarkedArticleDateRange(params.CreatedFrom, params.CreatedTo)
+	if err != nil {
+		return nil, err
+	}
+	domain := normalizeMarkedArticleDomain(params.Domain)
+	title := strings.ToLower(strings.TrimSpace(params.Title))
+	where, args := buildMarkedArticleListWhere(actor.TenantID, domain, title, createdFrom, createdTo)
+
+	var total int64
+	if err := s.monitoringPool.QueryRow(ctx, `
+		SELECT COUNT(*)::bigint
+		FROM monitoring_user_marked_articles
+		WHERE `+where, args...).Scan(&total); err != nil {
+		return nil, response.ErrInternal(50041, "marked_article_count_failed", "failed to count marked articles")
+	}
+
+	page := monitoringPageFromRequest(pageReq, total)
+	if total == 0 {
+		return &MonitoringMarkedArticleListResponse{Items: []MonitoringMarkedArticle{}, Page: page}, nil
+	}
+
+	listArgs := append([]interface{}{}, args...)
+	listArgs = append(listArgs, pageReq.PageSize, monitoringPageOffset(pageReq))
+	limitPlaceholder := len(listArgs) - 1
+	offsetPlaceholder := len(listArgs)
+	rows, err := s.monitoringPool.Query(ctx, `
+		SELECT
+			id,
+			brand_id,
+			article_title,
+			original_url,
+			normalized_url,
+			host,
+			registrable_domain,
+			site_key,
+			publish_platform,
+			marked_by_user_id,
+			marked_at,
+			expires_at,
+			created_at,
+			updated_at
+		FROM monitoring_user_marked_articles
+		WHERE `+where+`
+		ORDER BY created_at DESC, id DESC
+		LIMIT $`+strconv.Itoa(limitPlaceholder)+` OFFSET $`+strconv.Itoa(offsetPlaceholder), listArgs...)
+	if err != nil {
+		return nil, response.ErrInternal(50041, "marked_article_query_failed", "failed to load marked articles")
+	}
+	defer rows.Close()
+
+	items := make([]MonitoringMarkedArticle, 0, pageReq.PageSize)
+	for rows.Next() {
+		item, scanErr := scanMonitoringMarkedArticle(rows)
+		if scanErr != nil {
+			return nil, scanErr
+		}
+		items = append(items, item)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, response.ErrInternal(50041, "marked_article_scan_failed", "failed to iterate marked articles")
+	}
+
+	return &MonitoringMarkedArticleListResponse{Items: items, Page: page}, nil
+}
+
+func buildMarkedArticleListWhere(tenantID int64, domain, title string, createdFrom, createdTo *time.Time) (string, []interface{}) {
+	args := []interface{}{tenantID}
+	clauses := []string{
+		"tenant_id = $1",
+		"expires_at > NOW()",
+	}
+	if domain != "" {
+		args = append(args, strings.ToLower(domain))
+		placeholder := fmt.Sprintf("$%d", len(args))
+		clauses = append(clauses, "(registrable_domain = "+placeholder+" OR host = "+placeholder+" OR site_key = "+placeholder+")")
+	}
+	if title != "" {
+		args = append(args, "%"+title+"%")
+		clauses = append(clauses, "LOWER(article_title) LIKE "+fmt.Sprintf("$%d", len(args)))
+	}
+	if createdFrom != nil {
+		args = append(args, *createdFrom)
+		clauses = append(clauses, "created_at >= "+fmt.Sprintf("$%d", len(args)))
+	}
+	if createdTo != nil {
+		args = append(args, *createdTo)
+		clauses = append(clauses, "created_at <= "+fmt.Sprintf("$%d", len(args)))
+	}
+	return strings.Join(clauses, " AND "), args
+}
+
+func (s *MonitoringService) CreateMarkedArticle(ctx context.Context, req MonitoringMarkedArticleRequest) (*MonitoringMarkedArticle, error) {
+	actor := auth.MustActor(ctx)
+	meta, title, brandID, err := s.normalizeMarkedArticleRequest(ctx, actor.TenantID, req)
+	if err != nil {
+		return nil, err
+	}
+
+	var id int64
+	if err := s.monitoringPool.QueryRow(ctx, `
+		INSERT INTO monitoring_user_marked_articles (
+			tenant_id, brand_id, marked_by_user_id, article_title, original_url,
+			normalized_url, host, registrable_domain, site_key, last_path_segment,
+			publish_platform, expires_at
+		)
+		VALUES (
+			$1, $2, $3, $4, $5,
+			$6, $7, $8, $9, $10,
+			'外部文章', NOW() + INTERVAL '6 months'
+		)
+		ON CONFLICT (tenant_id, normalized_url)
+		DO UPDATE SET
+			brand_id = EXCLUDED.brand_id,
+			marked_by_user_id = EXCLUDED.marked_by_user_id,
+			article_title = EXCLUDED.article_title,
+			original_url = EXCLUDED.original_url,
+			host = EXCLUDED.host,
+			registrable_domain = EXCLUDED.registrable_domain,
+			site_key = EXCLUDED.site_key,
+			last_path_segment = EXCLUDED.last_path_segment,
+			publish_platform = EXCLUDED.publish_platform,
+			marked_at = NOW(),
+			expires_at = NOW() + INTERVAL '6 months',
+			updated_at = NOW()
+		RETURNING id
+	`,
+		actor.TenantID,
+		nullableInt64(brandID),
+		actor.UserID,
+		title,
+		meta.OriginalURL,
+		meta.NormalizedURL,
+		meta.Host,
+		meta.RegistrableDomain,
+		meta.SiteKey,
+		nullableString(meta.LastPathSegment),
+	).Scan(&id); err != nil {
+		return nil, response.ErrInternal(50041, "marked_article_create_failed", "failed to save marked article")
+	}
+
+	if err := s.syncMarkedArticleCitationFacts(ctx, actor.TenantID, id, meta.NormalizedURL); err != nil {
+		return nil, err
+	}
+
+	return s.GetMarkedArticle(ctx, id)
+}
+
+func (s *MonitoringService) UpdateMarkedArticle(ctx context.Context, id int64, req MonitoringMarkedArticleRequest) (*MonitoringMarkedArticle, error) {
+	if id <= 0 {
+		return nil, response.ErrBadRequest(40031, "invalid_marked_article_id", "marked article id must be a positive number")
+	}
+	actor := auth.MustActor(ctx)
+	meta, title, brandID, err := s.normalizeMarkedArticleRequest(ctx, actor.TenantID, req)
+	if err != nil {
+		return nil, err
+	}
+
+	var oldNormalizedURL string
+	if err := s.monitoringPool.QueryRow(ctx, `
+		SELECT normalized_url
+		FROM monitoring_user_marked_articles
+		WHERE id = $1
+		  AND tenant_id = $2
+		  AND expires_at > NOW()
+	`, id, actor.TenantID).Scan(&oldNormalizedURL); err != nil {
+		if err == pgx.ErrNoRows {
+			return nil, response.ErrNotFound(40441, "marked_article_not_found", "marked article not found")
+		}
+		return nil, response.ErrInternal(50041, "marked_article_lookup_failed", "failed to load marked article")
+	}
+	tag, err := s.monitoringPool.Exec(ctx, `
+		UPDATE monitoring_user_marked_articles
+		SET brand_id = $3,
+		    article_title = $4,
+		    original_url = $5,
+		    normalized_url = $6,
+		    host = $7,
+		    registrable_domain = $8,
+		    site_key = $9,
+		    last_path_segment = $10,
+		    expires_at = NOW() + INTERVAL '6 months',
+		    updated_at = NOW()
+		WHERE id = $1
+		  AND tenant_id = $2
+		  AND expires_at > NOW()
+	`, id, actor.TenantID, nullableInt64(brandID), title, meta.OriginalURL, meta.NormalizedURL, meta.Host, meta.RegistrableDomain, meta.SiteKey, nullableString(meta.LastPathSegment))
+	if err != nil {
+		return nil, response.ErrInternal(50041, "marked_article_update_failed", "failed to update marked article")
+	}
+	if tag.RowsAffected() == 0 {
+		return nil, response.ErrNotFound(40441, "marked_article_not_found", "marked article not found")
+	}
+	if oldNormalizedURL != "" && oldNormalizedURL != meta.NormalizedURL {
+		if err := s.clearMarkedArticleCitationFacts(ctx, actor.TenantID, id, oldNormalizedURL); err != nil {
+			return nil, err
+		}
+	}
+	if err := s.syncMarkedArticleCitationFacts(ctx, actor.TenantID, id, meta.NormalizedURL); err != nil {
+		return nil, err
+	}
+	return s.GetMarkedArticle(ctx, id)
+}
+
+func (s *MonitoringService) DeleteMarkedArticle(ctx context.Context, id int64) error {
+	if id <= 0 {
+		return response.ErrBadRequest(40031, "invalid_marked_article_id", "marked article id must be a positive number")
+	}
+	actor := auth.MustActor(ctx)
+	var normalizedURL string
+	if err := s.monitoringPool.QueryRow(ctx, `
+		SELECT normalized_url
+		FROM monitoring_user_marked_articles
+		WHERE id = $1 AND tenant_id = $2
+	`, id, actor.TenantID).Scan(&normalizedURL); err != nil {
+		if err == pgx.ErrNoRows {
+			return response.ErrNotFound(40441, "marked_article_not_found", "marked article not found")
+		}
+		return response.ErrInternal(50041, "marked_article_lookup_failed", "failed to load marked article")
+	}
+	tag, err := s.monitoringPool.Exec(ctx, `
+		DELETE FROM monitoring_user_marked_articles
+		WHERE id = $1 AND tenant_id = $2
+	`, id, actor.TenantID)
+	if err != nil {
+		return response.ErrInternal(50041, "marked_article_delete_failed", "failed to delete marked article")
+	}
+	if tag.RowsAffected() == 0 {
+		return response.ErrNotFound(40441, "marked_article_not_found", "marked article not found")
+	}
+	if err := s.clearMarkedArticleCitationFacts(ctx, actor.TenantID, id, normalizedURL); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (s *MonitoringService) GetMarkedArticle(ctx context.Context, id int64) (*MonitoringMarkedArticle, error) {
+	if id <= 0 {
+		return nil, response.ErrBadRequest(40031, "invalid_marked_article_id", "marked article id must be a positive number")
+	}
+	actor := auth.MustActor(ctx)
+	row := s.monitoringPool.QueryRow(ctx, `
+		SELECT
+			id,
+			brand_id,
+			article_title,
+			original_url,
+			normalized_url,
+			host,
+			registrable_domain,
+			site_key,
+			publish_platform,
+			marked_by_user_id,
+			marked_at,
+			expires_at,
+			created_at,
+			updated_at
+		FROM monitoring_user_marked_articles
+		WHERE id = $1
+		  AND tenant_id = $2
+		  AND expires_at > NOW()
+	`, id, actor.TenantID)
+	item, err := scanMonitoringMarkedArticle(row)
+	if err != nil {
+		if err == pgx.ErrNoRows {
+			return nil, response.ErrNotFound(40441, "marked_article_not_found", "marked article not found")
+		}
+		return nil, err
+	}
+	return &item, nil
+}
+
+func (s *MonitoringService) normalizeMarkedArticleRequest(ctx context.Context, tenantID int64, req MonitoringMarkedArticleRequest) (monitoringMarkedArticleURLMeta, string, *int64, error) {
+	title := strings.TrimSpace(req.ArticleTitle)
+	if title == "" {
+		return monitoringMarkedArticleURLMeta{}, "", nil, response.ErrBadRequest(40031, "marked_article_title_required", "article_title is required")
+	}
+	meta, err := normalizeMonitoringMarkedArticleURL(req.OriginalURL)
+	if err != nil {
+		return monitoringMarkedArticleURLMeta{}, "", nil, err
+	}
+	if req.BrandID != nil {
+		if _, err := s.resolveBrand(ctx, tenantID, *req.BrandID); err != nil {
+			return monitoringMarkedArticleURLMeta{}, "", nil, err
+		}
+	}
+	return meta, title, req.BrandID, nil
+}
+
+func normalizeMonitoringMarkedArticleURL(raw string) (monitoringMarkedArticleURLMeta, error) {
+	originalURL := strings.TrimSpace(raw)
+	if originalURL == "" {
+		return monitoringMarkedArticleURLMeta{}, response.ErrBadRequest(40031, "marked_article_url_required", "original_url is required")
+	}
+	parsed, err := url.Parse(originalURL)
+	if err != nil || parsed.Scheme == "" || parsed.Hostname() == "" {
+		return monitoringMarkedArticleURLMeta{}, response.ErrBadRequest(40031, "invalid_marked_article_url", "original_url must be an absolute URL")
+	}
+	normalizedURL := normalizeCitationURL(originalURL)
+	if normalizedURL == "" {
+		return monitoringMarkedArticleURLMeta{}, response.ErrBadRequest(40031, "invalid_marked_article_url", "original_url is invalid")
+	}
+	host, registrableDomain, _, _ := deriveCitationURLParts(originalURL, normalizedURL)
+	if host == "" || registrableDomain == "" {
+		return monitoringMarkedArticleURLMeta{}, response.ErrBadRequest(40031, "invalid_marked_article_url", "original_url host is invalid")
+	}
+	siteKey := host
+	if siteKey == "" {
+		siteKey = registrableDomain
+	}
+	return monitoringMarkedArticleURLMeta{
+		OriginalURL:       originalURL,
+		NormalizedURL:     normalizedURL,
+		Host:              host,
+		RegistrableDomain: registrableDomain,
+		SiteKey:           siteKey,
+		LastPathSegment:   monitoringAliasLastPathSegment(normalizedURL),
+	}, nil
+}
+
+func parseMarkedArticleDateRange(from, to string) (*time.Time, *time.Time, error) {
+	parse := func(value string, endOfDay bool) (*time.Time, error) {
+		trimmed := strings.TrimSpace(value)
+		if trimmed == "" {
+			return nil, nil
+		}
+		if parsed, err := time.Parse(time.RFC3339, trimmed); err == nil {
+			value := parsed.UTC()
+			return &value, nil
+		}
+		parsed, err := time.Parse("2006-01-02", trimmed)
+		if err != nil {
+			return nil, response.ErrBadRequest(40031, "invalid_marked_article_date_range", "date range must use RFC3339 or YYYY-MM-DD")
+		}
+		if endOfDay {
+			parsed = parsed.Add(24*time.Hour - time.Nanosecond)
+		}
+		return &parsed, nil
+	}
+	fromTime, err := parse(from, false)
+	if err != nil {
+		return nil, nil, err
+	}
+	toTime, err := parse(to, true)
+	if err != nil {
+		return nil, nil, err
+	}
+	if fromTime != nil && toTime != nil && fromTime.After(*toTime) {
+		return nil, nil, response.ErrBadRequest(40031, "invalid_marked_article_date_range", "created_from must be before created_to")
+	}
+	return fromTime, toTime, nil
+}
+
+func normalizeMarkedArticleDomain(value string) string {
+	trimmed := strings.ToLower(strings.TrimSpace(value))
+	trimmed = strings.TrimPrefix(trimmed, "http://")
+	trimmed = strings.TrimPrefix(trimmed, "https://")
+	trimmed = strings.Trim(trimmed, "/")
+	if idx := strings.IndexAny(trimmed, "/?#"); idx >= 0 {
+		trimmed = trimmed[:idx]
+	}
+	return trimmed
+}
+
+func (s *MonitoringService) syncMarkedArticleCitationFacts(ctx context.Context, tenantID, markedArticleID int64, normalizedURL string) error {
+	if tenantID <= 0 || markedArticleID <= 0 || strings.TrimSpace(normalizedURL) == "" {
+		return nil
+	}
+	if _, err := s.monitoringPool.Exec(ctx, `
+		UPDATE monitoring_citation_facts
+		SET content_source_type = 'manual_mark',
+		    content_source_id = $3
+		WHERE tenant_id = $1
+		  AND normalized_url = $2
+		  AND content_source_type IS NULL
+		  AND content_source_id IS NULL
+	`, tenantID, strings.TrimSpace(normalizedURL), markedArticleID); err != nil {
+		return response.ErrInternal(50041, "marked_article_citation_sync_failed", "failed to sync marked article citations")
+	}
+	return nil
+}
+
+func (s *MonitoringService) clearMarkedArticleCitationFacts(ctx context.Context, tenantID, markedArticleID int64, normalizedURL string) error {
+	if tenantID <= 0 || markedArticleID <= 0 {
+		return nil
+	}
+	args := []interface{}{tenantID, markedArticleID}
+	whereURL := ""
+	if trimmed := strings.TrimSpace(normalizedURL); trimmed != "" {
+		args = append(args, trimmed)
+		whereURL = " AND normalized_url = $3"
+	}
+	if _, err := s.monitoringPool.Exec(ctx, `
+		UPDATE monitoring_citation_facts
+		SET content_source_type = NULL,
+		    content_source_id = NULL
+		WHERE tenant_id = $1
+		  AND content_source_type = 'manual_mark'
+		  AND content_source_id = $2
+	`+whereURL, args...); err != nil {
+		return response.ErrInternal(50041, "marked_article_citation_clear_failed", "failed to clear marked article citations")
+	}
+	return nil
+}
+
+func nullableTimePtr(value *time.Time) interface{} {
+	if value == nil {
+		return nil
+	}
+	return *value
+}
+
+type monitoringMarkedArticleScanner interface {
+	Scan(dest ...interface{}) error
+}
+
+func scanMonitoringMarkedArticle(row monitoringMarkedArticleScanner) (MonitoringMarkedArticle, error) {
+	var item MonitoringMarkedArticle
+	var brandID sql.NullInt64
+	var markedByUserID sql.NullInt64
+	var markedAt time.Time
+	var expiresAt time.Time
+	var createdAt time.Time
+	var updatedAt time.Time
+	if err := row.Scan(
+		&item.ID,
+		&brandID,
+		&item.ArticleTitle,
+		&item.OriginalURL,
+		&item.NormalizedURL,
+		&item.Host,
+		&item.RegistrableDomain,
+		&item.SiteKey,
+		&item.PublishPlatform,
+		&markedByUserID,
+		&markedAt,
+		&expiresAt,
+		&createdAt,
+		&updatedAt,
+	); err != nil {
+		if err == pgx.ErrNoRows {
+			return item, err
+		}
+		return item, response.ErrInternal(50041, "marked_article_scan_failed", "failed to parse marked article")
+	}
+	item.BrandID = nullableInt64Value(brandID)
+	item.MarkedByUserID = nullableInt64Value(markedByUserID)
+	item.MarkedAt = markedAt.UTC().Format(time.RFC3339)
+	item.ExpiresAt = expiresAt.UTC().Format(time.RFC3339)
+	item.CreatedAt = createdAt.UTC().Format(time.RFC3339)
+	item.UpdatedAt = updatedAt.UTC().Format(time.RFC3339)
+	return item, nil
+}
diff --git a/server/internal/tenant/app/monitoring_projection.go b/server/internal/tenant/app/monitoring_projection.go
index cbb0e09..7ae441f 100644
--- a/server/internal/tenant/app/monitoring_projection.go
+++ b/server/internal/tenant/app/monitoring_projection.go
@@ -213,7 +213,9 @@ func (s *MonitoringCallbackService) loadMonitoringBrandDailyAggregate(ctx contex
 			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 cf.business_date = $4::date
+		  AND cf.content_source_type IS NOT NULL
+		  AND cf.content_source_id IS NOT NULL
 		  AND r.ai_platform_id <> 'qwen'
 		  AND r.collector_type = $3
 		  AND r.business_date = $4::date
diff --git a/server/internal/tenant/app/monitoring_service.go b/server/internal/tenant/app/monitoring_service.go
index 9d98c8a..2ecf4ae 100644
--- a/server/internal/tenant/app/monitoring_service.go
+++ b/server/internal/tenant/app/monitoring_service.go
@@ -10,6 +10,7 @@ import (
 	"fmt"
 	"math/big"
 	"sort"
+	"strconv"
 	"strings"
 	"sync"
 	"time"
@@ -192,9 +193,12 @@ type MonitoringCitationRanking struct {
 }
 
 type MonitoringCitedArticle struct {
-	ArticleID       int64    `json:"article_id"`
+	ArticleID       *int64   `json:"article_id"`
 	ArticleTitle    string   `json:"article_title"`
 	PublishPlatform string   `json:"publish_platform"`
+	SourceType      string   `json:"source_type"`
+	SourceID        int64    `json:"source_id"`
+	SourceURL       string   `json:"source_url"`
 	CitationCount   int64    `json:"citation_count"`
 	CitationRate    *float64 `json:"citation_rate"`
 	SourceShare     *float64 `json:"source_share"`
@@ -237,6 +241,9 @@ type MonitoringQuestionDetailCitation struct {
 	SiteKey              string  `json:"site_key"`
 	FaviconURL           string  `json:"favicon_url"`
 	ArticleID            *int64  `json:"article_id"`
+	SourceType           *string `json:"source_type,omitempty"`
+	SourceID             *int64  `json:"source_id,omitempty"`
+	SourceURL            *string `json:"source_url,omitempty"`
 	ArticleTitle         *string `json:"article_title,omitempty"`
 	ResolutionStatus     string  `json:"resolution_status"`
 	ResolutionConfidence string  `json:"resolution_confidence"`
@@ -254,9 +261,12 @@ type MonitoringQuestionCitationStats struct {
 }
 
 type MonitoringQuestionContentCitation struct {
-	ArticleID       int64    `json:"article_id"`
+	ArticleID       *int64   `json:"article_id"`
 	ArticleTitle    string   `json:"article_title"`
 	PublishPlatform string   `json:"publish_platform"`
+	SourceType      string   `json:"source_type"`
+	SourceID        int64    `json:"source_id"`
+	SourceURL       string   `json:"source_url"`
 	AIPlatformID    string   `json:"ai_platform_id"`
 	PlatformName    string   `json:"platform_name"`
 	CitationCount   int64    `json:"citation_count"`
@@ -3458,11 +3468,6 @@ func (s *MonitoringService) loadCitationRanking(
 	}
 	platformQueryIDs := monitoringPlatformQueryIDs(aiPlatformID)
 
-	aliasIndex, err := loadMonitoringPublishedAliasIndex(ctx, s.monitoringPool, tenantID)
-	if err != nil {
-		return nil, err
-	}
-
 	type citationRankingAggregate struct {
 		CitedAnswerCount    int64
 		CitedArticleCount   int64
@@ -3473,18 +3478,57 @@ func (s *MonitoringService) loadCitationRanking(
 
 	aggregates := make(map[string]citationRankingAggregate)
 	rows, err := s.monitoringPool.Query(ctx, `
+		WITH filtered_runs AS (
+			SELECT id, ai_platform_id
+			FROM question_monitor_runs
+			WHERE tenant_id = $1
+			  AND ($2::bigint = 0 OR brand_id = $2)
+			  AND collector_type = $3
+			  AND status = 'succeeded'
+			  AND business_date BETWEEN $4::date AND $5::date
+			  AND ($6::bigint[] IS NULL OR question_id = ANY($6))
+			  AND ($7::text[] IS NULL OR ai_platform_id = ANY($7))
+		),
+		sample_counts AS (
+			SELECT ai_platform_id, COUNT(*)::bigint AS sample_count
+			FROM filtered_runs
+			GROUP BY ai_platform_id
+		),
+		citation_counts AS (
+			SELECT
+				fr.ai_platform_id,
+				COUNT(cf.id)::bigint AS citation_source_count,
+				COUNT(cf.id) FILTER (
+					WHERE fr.ai_platform_id <> 'qwen'
+					  AND cf.content_source_type IS NOT NULL
+					  AND cf.content_source_id IS NOT NULL
+				)::bigint AS saas_source_count,
+				COUNT(DISTINCT cf.run_id) FILTER (
+					WHERE fr.ai_platform_id <> 'qwen'
+					  AND cf.content_source_type IS NOT NULL
+					  AND cf.content_source_id IS NOT NULL
+				)::bigint AS cited_answer_count,
+				COUNT(DISTINCT cf.content_source_type || ':' || cf.content_source_id::text) FILTER (
+					WHERE fr.ai_platform_id <> 'qwen'
+					  AND cf.content_source_type IS NOT NULL
+					  AND cf.content_source_id IS NOT NULL
+				)::bigint AS cited_article_count
+			FROM filtered_runs fr
+			JOIN monitoring_citation_facts cf
+			  ON cf.tenant_id = $1
+			 AND cf.run_id = fr.id
+			 AND cf.business_date BETWEEN $4::date AND $5::date
+			GROUP BY fr.ai_platform_id
+		)
 		SELECT
-			r.ai_platform_id,
-			COUNT(*) AS sample_count
-		FROM question_monitor_runs r
-		WHERE r.tenant_id = $1
-		  AND ($2::bigint = 0 OR 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))
-		  AND ($7::text[] IS NULL OR r.ai_platform_id = ANY($7))
-		GROUP BY r.ai_platform_id
+			sc.ai_platform_id,
+			sc.sample_count,
+			COALESCE(cc.citation_source_count, 0)::bigint,
+			COALESCE(cc.saas_source_count, 0)::bigint,
+			COALESCE(cc.cited_answer_count, 0)::bigint,
+			COALESCE(cc.cited_article_count, 0)::bigint
+		FROM sample_counts sc
+		LEFT JOIN citation_counts cc ON cc.ai_platform_id = sc.ai_platform_id
 	`, tenantID, brandID, monitoringCollectorType, startDate.Format("2006-01-02"), endDate.Format("2006-01-02"), nullableInt64Array(questionIDs), nullableStringArray(platformQueryIDs))
 	if err != nil {
 		return nil, response.ErrInternal(50041, "query_failed", "failed to load citation ranking")
@@ -3494,7 +3538,18 @@ func (s *MonitoringService) loadCitationRanking(
 	for rows.Next() {
 		var platformID string
 		var sampleCount int64
-		if scanErr := rows.Scan(&platformID, &sampleCount); scanErr != nil {
+		var citationSourceCount int64
+		var saasSourceCount int64
+		var citedAnswerCount int64
+		var citedArticleCount int64
+		if scanErr := rows.Scan(
+			&platformID,
+			&sampleCount,
+			&citationSourceCount,
+			&saasSourceCount,
+			&citedAnswerCount,
+			&citedArticleCount,
+		); scanErr != nil {
 			return nil, response.ErrInternal(50041, "scan_failed", "failed to parse citation ranking")
 		}
 		platformID = normalizeMonitoringPlatformID(platformID)
@@ -3503,74 +3558,16 @@ func (s *MonitoringService) loadCitationRanking(
 		}
 		item := aggregates[platformID]
 		item.SampleCount += sampleCount
+		item.CitationSourceCount += citationSourceCount
+		item.SaaSSourceCount += saasSourceCount
+		item.CitedAnswerCount += citedAnswerCount
+		item.CitedArticleCount += citedArticleCount
 		aggregates[platformID] = item
 	}
 	if err := rows.Err(); err != nil {
 		return nil, response.ErrInternal(50041, "scan_failed", "failed to iterate citation ranking")
 	}
 
-	citedRuns := make(map[string]map[int64]struct{})
-	citedArticles := make(map[string]map[int64]struct{})
-	rows, err = s.monitoringPool.Query(ctx, `
-		SELECT
-			r.ai_platform_id,
-			cf.run_id,
-			cf.cited_url,
-			cf.normalized_url
-		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 ($2::bigint = 0 OR 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))
-		  AND ($7::text[] IS NULL OR r.ai_platform_id = ANY($7))
-	`, tenantID, brandID, monitoringCollectorType, startDate.Format("2006-01-02"), endDate.Format("2006-01-02"), nullableInt64Array(questionIDs), nullableStringArray(platformQueryIDs))
-	if err != nil {
-		return nil, response.ErrInternal(50041, "query_failed", "failed to load citation ranking")
-	}
-	defer rows.Close()
-
-	for rows.Next() {
-		var platformID string
-		var runID int64
-		var citedURL string
-		var normalizedURL string
-		if scanErr := rows.Scan(&platformID, &runID, &citedURL, &normalizedURL); scanErr != nil {
-			return nil, response.ErrInternal(50041, "scan_failed", "failed to parse citation ranking")
-		}
-		platformID = normalizeMonitoringPlatformID(platformID)
-		if platformID == "" {
-			continue
-		}
-		item := aggregates[platformID]
-		item.CitationSourceCount++
-		if platformID != "qwen" {
-			if alias, ok := aliasIndex.Match(citedURL, normalizedURL); ok {
-				item.SaaSSourceCount++
-				if _, exists := citedRuns[platformID]; !exists {
-					citedRuns[platformID] = make(map[int64]struct{})
-				}
-				citedRuns[platformID][runID] = struct{}{}
-				if _, exists := citedArticles[platformID]; !exists {
-					citedArticles[platformID] = make(map[int64]struct{})
-				}
-				citedArticles[platformID][alias.ArticleID] = struct{}{}
-			}
-		}
-		aggregates[platformID] = item
-	}
-	if err := rows.Err(); err != nil {
-		return nil, response.ErrInternal(50041, "scan_failed", "failed to iterate citation ranking")
-	}
-	for platformID, item := range aggregates {
-		item.CitedAnswerCount = int64(len(citedRuns[platformID]))
-		item.CitedArticleCount = int64(len(citedArticles[platformID]))
-		aggregates[platformID] = item
-	}
-
 	items := make([]MonitoringCitationRanking, 0, len(aggregates))
 	for platformID, aggregate := range aggregates {
 		if aggregate.SaaSSourceCount == 0 {
@@ -3611,123 +3608,9 @@ func (s *MonitoringService) loadCitedArticles(
 	startDate, endDate time.Time,
 	aiPlatformID *string,
 ) ([]MonitoringCitedArticle, error) {
-	if questionIDs != nil && len(questionIDs) == 0 {
-		return []MonitoringCitedArticle{}, nil
-	}
-	platformQueryIDs := monitoringPlatformQueryIDs(aiPlatformID)
-
-	aliasIndex, err := loadMonitoringPublishedAliasIndex(ctx, s.monitoringPool, tenantID)
-	if err != nil {
-		return nil, err
-	}
-
-	var totalSampleCount int64
-	if err := s.monitoringPool.QueryRow(ctx, `
-		SELECT COUNT(*)
-		FROM question_monitor_runs r
-		WHERE r.tenant_id = $1
-		  AND ($2::bigint = 0 OR 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))
-		  AND ($7::text[] IS NULL OR r.ai_platform_id = ANY($7))
-	`, tenantID, brandID, monitoringCollectorType, startDate.Format("2006-01-02"), endDate.Format("2006-01-02"), nullableInt64Array(questionIDs), nullableStringArray(platformQueryIDs)).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.cited_url,
-			cf.normalized_url,
-			NULLIF(cf.article_id, 0),
-			NULLIF(cf.cited_title, '')
-		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 ($2::bigint = 0 OR cf.brand_id = $2)
-		  AND r.ai_platform_id <> 'qwen'
-		  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))
-		  AND ($7::text[] IS NULL OR r.ai_platform_id = ANY($7))
-	`, tenantID, brandID, monitoringCollectorType, startDate.Format("2006-01-02"), endDate.Format("2006-01-02"), nullableInt64Array(questionIDs), nullableStringArray(platformQueryIDs))
-	if err != nil {
-		return nil, response.ErrInternal(50041, "query_failed", "failed to load cited articles")
-	}
-	defer rows.Close()
-
-	type citedArticleAggregate struct {
-		ArticleID       int64
-		ArticleTitle    string
-		PublishPlatform string
-		CitationCount   int64
-	}
-	aggregates := make(map[int64]citedArticleAggregate)
-	var totalArticleCitationCount int64
-	for rows.Next() {
-		var citedURL string
-		var normalizedURL string
-		var factArticleID sql.NullInt64
-		var factCitedTitle sql.NullString
-		if scanErr := rows.Scan(&citedURL, &normalizedURL, &factArticleID, &factCitedTitle); scanErr != nil {
-			return nil, response.ErrInternal(50041, "scan_failed", "failed to parse cited articles")
-		}
-		alias, ok := aliasIndex.Match(citedURL, normalizedURL)
-
-		articleID := factArticleID.Int64
-		if !factArticleID.Valid && ok {
-			articleID = alias.ArticleID
-		}
-		if articleID <= 0 {
-			continue
-		}
-
-		item := aggregates[articleID]
-		if item.ArticleID == 0 {
-			item.ArticleID = articleID
-			if ok && strings.TrimSpace(alias.ArticleTitle) != "" {
-				item.ArticleTitle = alias.ArticleTitle
-			} else if factCitedTitle.Valid && strings.TrimSpace(factCitedTitle.String) != "" {
-				item.ArticleTitle = factCitedTitle.String
-			} else {
-				item.ArticleTitle = "未命名文章"
-			}
-			if ok && strings.TrimSpace(alias.PublishPlatform) != "" {
-				item.PublishPlatform = alias.PublishPlatform
-			} else {
-				item.PublishPlatform = "已发布内容"
-			}
-		}
-		item.CitationCount++
-		totalArticleCitationCount++
-		aggregates[articleID] = item
-	}
-	if err := rows.Err(); err != nil {
-		return nil, response.ErrInternal(50041, "scan_failed", "failed to iterate cited articles")
-	}
-
-	items := make([]MonitoringCitedArticle, 0, len(aggregates))
-	for _, item := range aggregates {
-		items = append(items, MonitoringCitedArticle{
-			ArticleID:       item.ArticleID,
-			ArticleTitle:    item.ArticleTitle,
-			PublishPlatform: item.PublishPlatform,
-			CitationCount:   item.CitationCount,
-			CitationRate:    divideAsPointer(item.CitationCount, totalSampleCount),
-			SourceShare:     divideAsPointer(item.CitationCount, totalArticleCitationCount),
-		})
-	}
-	sort.Slice(items, func(left, right int) bool {
-		if items[left].CitationCount != items[right].CitationCount {
-			return items[left].CitationCount > items[right].CitationCount
-		}
-		return items[left].ArticleID < items[right].ArticleID
-	})
-
-	return items, nil
+	pageReq := MonitoringPageRequest{Page: 1, PageSize: maxMonitoringListPageSize}
+	items, _, err := s.loadCitedArticlesPage(ctx, tenantID, brandID, questionIDs, startDate, endDate, aiPlatformID, pageReq)
+	return items, err
 }
 
 func (s *MonitoringService) loadCitedArticlesPage(
@@ -3761,94 +3644,238 @@ func (s *MonitoringService) loadCitedArticlesPage(
 		return nil, MonitoringPage{}, response.ErrInternal(50041, "query_failed", "failed to count cited article denominator")
 	}
 
-	type citedArticleStats struct {
-		Total              int64
-		TotalCitationCount int64
+	sourceRows, totalArticleCitationCount, totalSources, err := s.loadCitedArticleSourceRows(ctx, tenantID, brandID, questionIDs, startDateText, endDateText, platformQueryIDs, pageReq)
+	if err != nil {
+		return nil, MonitoringPage{}, err
 	}
-	var stats citedArticleStats
-	if err := s.monitoringPool.QueryRow(ctx, `
-		WITH article_counts AS (
-			SELECT COALESCE(NULLIF(cf.article_id, 0), alias.article_id) AS article_id,
-			       COUNT(*)::bigint 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.normalized_url = cf.normalized_url
-			   AND alias.confidence = 'high'
-			WHERE cf.tenant_id = $1
-			  AND ($2::bigint = 0 OR cf.brand_id = $2)
-			  AND r.ai_platform_id <> 'qwen'
-			  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))
-			  AND ($7::text[] IS NULL OR r.ai_platform_id = ANY($7))
-			  AND COALESCE(NULLIF(cf.article_id, 0), alias.article_id) IS NOT NULL
-			GROUP BY COALESCE(NULLIF(cf.article_id, 0), alias.article_id)
-		)
-		SELECT COUNT(*)::bigint, COALESCE(SUM(citation_count), 0)::bigint
-		FROM article_counts
-	`, tenantID, brandID, monitoringCollectorType, startDateText, endDateText, nullableInt64Array(questionIDs), nullableStringArray(platformQueryIDs)).Scan(&stats.Total, &stats.TotalCitationCount); err != nil {
-		return nil, MonitoringPage{}, response.ErrInternal(50041, "query_failed", "failed to count cited articles")
-	}
-
-	page := monitoringPageFromRequest(pageReq, stats.Total)
-	if stats.Total == 0 {
+	page := monitoringPageFromRequest(pageReq, totalSources)
+	if len(sourceRows) == 0 {
 		return []MonitoringCitedArticle{}, page, nil
 	}
 
+	metaByKey, err := s.loadCitedArticleSourceMeta(ctx, tenantID, sourceRows)
+	if err != nil {
+		return nil, MonitoringPage{}, err
+	}
+	items := make([]MonitoringCitedArticle, 0, len(sourceRows))
+	for _, source := range sourceRows {
+		item := metaByKey[monitoringContentSourceKey(source.SourceType, source.SourceID)]
+		if item.SourceID == 0 {
+			item = MonitoringCitedArticle{
+				ArticleTitle:    "未命名文章",
+				PublishPlatform: "外部文章",
+				SourceType:      source.SourceType,
+				SourceID:        source.SourceID,
+			}
+		}
+		item.CitationCount = source.CitationCount
+		item.CitationRate = divideAsPointer(source.CitationCount, totalSampleCount)
+		item.SourceShare = divideAsPointer(source.CitationCount, totalArticleCitationCount)
+		items = append(items, item)
+	}
+
+	return items, page, nil
+}
+
+type monitoringCitedArticleSourceRow struct {
+	SourceType    string
+	SourceID      int64
+	CitationCount int64
+}
+
+func (s *MonitoringService) loadCitedArticleSourceRows(
+	ctx context.Context,
+	tenantID, brandID int64,
+	questionIDs []int64,
+	startDateText, endDateText string,
+	platformQueryIDs []string,
+	pageReq MonitoringPageRequest,
+) ([]monitoringCitedArticleSourceRow, int64, int64, error) {
 	rows, err := s.monitoringPool.Query(ctx, `
-		WITH article_counts AS (
+		WITH filtered_sources AS (
 			SELECT
-				COALESCE(NULLIF(cf.article_id, 0), alias.article_id) AS article_id,
-				COALESCE(MAX(alias.article_title_snapshot), MAX(NULLIF(cf.cited_title, '')), '未命名文章') AS article_title,
-				COALESCE(MAX(alias.publish_platform_name_snapshot), '已发布内容') AS publish_platform,
+				cf.content_source_type,
+				cf.content_source_id,
 				COUNT(*)::bigint 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.normalized_url = cf.normalized_url
-			   AND alias.confidence = 'high'
+			  ON r.tenant_id = cf.tenant_id
+			 AND r.id = cf.run_id
 			WHERE cf.tenant_id = $1
 			  AND ($2::bigint = 0 OR cf.brand_id = $2)
-			  AND r.ai_platform_id <> 'qwen'
+			  AND cf.ai_platform_id <> 'qwen'
+			  AND cf.business_date BETWEEN $4::date AND $5::date
+			  AND cf.content_source_type IS NOT NULL
+			  AND cf.content_source_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))
 			  AND ($7::text[] IS NULL OR r.ai_platform_id = ANY($7))
-			  AND COALESCE(NULLIF(cf.article_id, 0), alias.article_id) IS NOT NULL
-			GROUP BY COALESCE(NULLIF(cf.article_id, 0), alias.article_id)
+			GROUP BY cf.content_source_type, cf.content_source_id
+		),
+		counts AS (
+			SELECT
+				COALESCE(SUM(citation_count), 0)::bigint AS total_citation_count,
+				COUNT(*)::bigint AS total_source_count
+			FROM filtered_sources
+		),
+		paged_sources AS (
+			SELECT content_source_type, content_source_id, citation_count
+			FROM filtered_sources
+			ORDER BY citation_count DESC, content_source_type ASC, content_source_id ASC
+			LIMIT $8 OFFSET $9
 		)
-		SELECT article_id, article_title, publish_platform, citation_count
-		FROM article_counts
-		ORDER BY citation_count DESC, article_id ASC
-		LIMIT $8 OFFSET $9
+		SELECT
+			ps.content_source_type,
+			ps.content_source_id,
+			ps.citation_count,
+			counts.total_citation_count,
+			counts.total_source_count
+		FROM counts
+		LEFT JOIN paged_sources ps ON TRUE
 	`, tenantID, brandID, monitoringCollectorType, startDateText, endDateText, nullableInt64Array(questionIDs), nullableStringArray(platformQueryIDs), pageReq.PageSize, monitoringPageOffset(pageReq))
 	if err != nil {
-		return nil, MonitoringPage{}, response.ErrInternal(50041, "query_failed", "failed to load cited articles")
+		return nil, 0, 0, response.ErrInternal(50041, "query_failed", "failed to load cited articles")
 	}
 	defer rows.Close()
 
-	items := make([]MonitoringCitedArticle, 0, pageReq.PageSize)
+	items := make([]monitoringCitedArticleSourceRow, 0, pageReq.PageSize)
+	var totalCitationCount int64
+	var totalSourceCount int64
 	for rows.Next() {
-		var item MonitoringCitedArticle
-		if scanErr := rows.Scan(&item.ArticleID, &item.ArticleTitle, &item.PublishPlatform, &item.CitationCount); scanErr != nil {
-			return nil, MonitoringPage{}, response.ErrInternal(50041, "scan_failed", "failed to parse cited articles")
+		var sourceType sql.NullString
+		var sourceID sql.NullInt64
+		var citationCount sql.NullInt64
+		if scanErr := rows.Scan(
+			&sourceType,
+			&sourceID,
+			&citationCount,
+			&totalCitationCount,
+			&totalSourceCount,
+		); scanErr != nil {
+			return nil, 0, 0, response.ErrInternal(50041, "scan_failed", "failed to parse cited articles")
+		}
+		if !sourceType.Valid || !sourceID.Valid || !citationCount.Valid {
+			continue
+		}
+		item := monitoringCitedArticleSourceRow{
+			SourceType:    strings.TrimSpace(sourceType.String),
+			SourceID:      sourceID.Int64,
+			CitationCount: citationCount.Int64,
+		}
+		if item.SourceType == "" || item.SourceID <= 0 {
+			continue
 		}
-		item.CitationRate = divideAsPointer(item.CitationCount, totalSampleCount)
-		item.SourceShare = divideAsPointer(item.CitationCount, stats.TotalCitationCount)
 		items = append(items, item)
 	}
 	if err := rows.Err(); err != nil {
-		return nil, MonitoringPage{}, response.ErrInternal(50041, "scan_failed", "failed to iterate cited articles")
+		return nil, 0, 0, response.ErrInternal(50041, "scan_failed", "failed to iterate cited articles")
 	}
 
-	return items, page, nil
+	return items, totalCitationCount, totalSourceCount, nil
+}
+
+func (s *MonitoringService) loadCitedArticleSourceMeta(ctx context.Context, tenantID int64, sources []monitoringCitedArticleSourceRow) (map[string]MonitoringCitedArticle, error) {
+	result := make(map[string]MonitoringCitedArticle, len(sources))
+	publishedIDs := make([]int64, 0, len(sources))
+	manualIDs := make([]int64, 0, len(sources))
+	for _, source := range sources {
+		switch source.SourceType {
+		case "published_article":
+			publishedIDs = append(publishedIDs, source.SourceID)
+		case "manual_mark":
+			manualIDs = append(manualIDs, source.SourceID)
+		}
+	}
+	if len(publishedIDs) > 0 {
+		rows, err := s.monitoringPool.Query(ctx, `
+			SELECT DISTINCT ON (article_id)
+				article_id,
+				COALESCE(NULLIF(article_title_snapshot, ''), '未命名文章') AS article_title,
+				COALESCE(NULLIF(publish_platform_name_snapshot, ''), '已发布内容') AS publish_platform,
+				COALESCE(NULLIF(original_url, ''), normalized_url) AS source_url
+			FROM monitoring_article_url_aliases
+			WHERE tenant_id = $1
+			  AND confidence = 'high'
+			  AND article_id = ANY($2)
+			ORDER BY article_id, updated_at DESC, id DESC
+		`, tenantID, publishedIDs)
+		if err != nil {
+			return nil, response.ErrInternal(50041, "query_failed", "failed to load cited article metadata")
+		}
+		defer rows.Close()
+		for rows.Next() {
+			var articleID int64
+			var item MonitoringCitedArticle
+			if scanErr := rows.Scan(&articleID, &item.ArticleTitle, &item.PublishPlatform, &item.SourceURL); scanErr != nil {
+				return nil, response.ErrInternal(50041, "scan_failed", "failed to parse cited article metadata")
+			}
+			value := articleID
+			item.ArticleID = &value
+			item.ArticleTitle = repairMonitoringMojibake(item.ArticleTitle)
+			item.PublishPlatform = repairMonitoringMojibake(item.PublishPlatform)
+			item.SourceType = "published_article"
+			item.SourceID = articleID
+			result[monitoringContentSourceKey(item.SourceType, item.SourceID)] = item
+		}
+		if err := rows.Err(); err != nil {
+			return nil, response.ErrInternal(50041, "scan_failed", "failed to iterate cited article metadata")
+		}
+	}
+	if len(manualIDs) > 0 {
+		rows, err := s.monitoringPool.Query(ctx, `
+			SELECT
+				id,
+				COALESCE(NULLIF(article_title, ''), '未命名文章') AS article_title,
+				COALESCE(NULLIF(publish_platform, ''), '外部文章') AS publish_platform,
+				COALESCE(NULLIF(original_url, ''), normalized_url) AS source_url
+			FROM monitoring_user_marked_articles
+			WHERE tenant_id = $1
+			  AND id = ANY($2)
+		`, tenantID, manualIDs)
+		if err != nil {
+			return nil, response.ErrInternal(50041, "query_failed", "failed to load marked article metadata")
+		}
+		defer rows.Close()
+		for rows.Next() {
+			var item MonitoringCitedArticle
+			if scanErr := rows.Scan(&item.SourceID, &item.ArticleTitle, &item.PublishPlatform, &item.SourceURL); scanErr != nil {
+				return nil, response.ErrInternal(50041, "scan_failed", "failed to parse marked article metadata")
+			}
+			item.ArticleTitle = repairMonitoringMojibake(item.ArticleTitle)
+			item.PublishPlatform = repairMonitoringMojibake(item.PublishPlatform)
+			item.SourceType = "manual_mark"
+			result[monitoringContentSourceKey(item.SourceType, item.SourceID)] = item
+		}
+		if err := rows.Err(); err != nil {
+			return nil, response.ErrInternal(50041, "scan_failed", "failed to iterate marked article metadata")
+		}
+	}
+	return result, nil
+}
+
+func monitoringContentSourceKey(sourceType string, sourceID int64) string {
+	return strings.TrimSpace(sourceType) + ":" + strconv.FormatInt(sourceID, 10)
+}
+
+func monitoringAliasContentKey(alias monitoringPublishedAlias) string {
+	sourceType := strings.TrimSpace(alias.SourceType)
+	sourceID := alias.SourceID
+	if sourceType == "" {
+		sourceType = "published_article"
+	}
+	if sourceID == 0 && alias.ArticleID > 0 {
+		sourceID = alias.ArticleID
+	}
+	if sourceID > 0 {
+		return sourceType + ":" + strconv.FormatInt(sourceID, 10)
+	}
+	key := strings.TrimSpace(alias.NormalizedURL)
+	if key == "" {
+		key = strings.TrimSpace(alias.OriginalURL)
+	}
+	return sourceType + ":url:" + key
 }
 
 func (s *MonitoringService) loadQuestionText(ctx context.Context, tenantID, brandID, questionID int64) (string, error) {
@@ -4130,10 +4157,35 @@ func (s *MonitoringService) loadCitationsForRuns(ctx context.Context, tenantID i
 		}
 		var articleID *int64
 		var articleTitle *string
+		var sourceType *string
+		var sourceID *int64
+		var sourceURL *string
 		if alias, ok := aliasIndex.Match(citedURL, normalizedURL); ok {
-			articleID = &alias.ArticleID
+			if alias.ArticleID > 0 {
+				value := alias.ArticleID
+				articleID = &value
+			}
 			title := repairMonitoringMojibake(alias.ArticleTitle)
 			articleTitle = &title
+			aliasSourceType := strings.TrimSpace(alias.SourceType)
+			if aliasSourceType == "" {
+				aliasSourceType = "published_article"
+			}
+			sourceType = &aliasSourceType
+			aliasSourceID := alias.SourceID
+			if aliasSourceID == 0 && alias.ArticleID > 0 {
+				aliasSourceID = alias.ArticleID
+			}
+			if aliasSourceID > 0 {
+				sourceID = &aliasSourceID
+			}
+			aliasSourceURL := strings.TrimSpace(alias.OriginalURL)
+			if aliasSourceURL == "" {
+				aliasSourceURL = strings.TrimSpace(alias.NormalizedURL)
+			}
+			if aliasSourceURL != "" {
+				sourceURL = &aliasSourceURL
+			}
 			resolutionStatus = "resolved"
 			resolutionConfidence = "high"
 		}
@@ -4144,6 +4196,9 @@ func (s *MonitoringService) loadCitationsForRuns(ctx context.Context, tenantID i
 			SiteKey:              siteKey,
 			FaviconURL:           faviconURL(siteKey),
 			ArticleID:            articleID,
+			SourceType:           sourceType,
+			SourceID:             sourceID,
+			SourceURL:            sourceURL,
 			ArticleTitle:         articleTitle,
 			ResolutionStatus:     resolutionStatus,
 			ResolutionConfidence: resolutionConfidence,
@@ -4161,21 +4216,16 @@ func (s *MonitoringService) loadQuestionCitationAnalysis(ctx context.Context, te
 		return []MonitoringQuestionCitationStats{}, nil
 	}
 
-	aliasIndex, err := loadMonitoringPublishedAliasIndex(ctx, s.monitoringPool, tenantID)
-	if err != nil {
-		return nil, err
-	}
-
 	rows, err := s.monitoringPool.Query(ctx, `
 		WITH filtered_facts AS (
 			SELECT
 				r.ai_platform_id,
 				cf.id,
-				cf.cited_url,
-				cf.normalized_url,
 				cf.host,
 				cf.registrable_domain,
-				cf.site_key
+				cf.site_key,
+				cf.content_source_type,
+				cf.content_source_id
 			FROM question_monitor_runs r
 			JOIN monitoring_citation_facts cf
 				ON cf.tenant_id = r.tenant_id AND cf.run_id = r.id
@@ -4220,11 +4270,11 @@ func (s *MonitoringService) loadQuestionCitationAnalysis(ctx context.Context, te
 		)
 		SELECT
 			ff.ai_platform_id,
-			ff.cited_url,
-			ff.normalized_url,
 			COALESCE(dm.mapped_site_name, ff.site_key, ff.registrable_domain) AS site_name,
 			COALESCE(dm.mapped_site_key, ff.site_key) AS site_key,
-			COALESCE(dm.mapped_domain, ff.site_key, ff.registrable_domain) AS site_domain
+			COALESCE(dm.mapped_domain, ff.site_key, ff.registrable_domain) AS site_domain,
+			ff.content_source_type,
+			ff.content_source_id
 		FROM filtered_facts ff
 		LEFT JOIN domain_mappings dm
 			ON dm.host = ff.host
@@ -4246,12 +4296,12 @@ func (s *MonitoringService) loadQuestionCitationAnalysis(ctx context.Context, te
 	totals := make(map[string]int64)
 	for rows.Next() {
 		var platformID string
-		var citedURL string
-		var normalizedURL string
 		var siteName string
 		var siteKey string
 		var siteDomain string
-		if scanErr := rows.Scan(&platformID, &citedURL, &normalizedURL, &siteName, &siteKey, &siteDomain); scanErr != nil {
+		var sourceType sql.NullString
+		var sourceID sql.NullInt64
+		if scanErr := rows.Scan(&platformID, &siteName, &siteKey, &siteDomain, &sourceType, &sourceID); scanErr != nil {
 			return nil, response.ErrInternal(50041, "scan_failed", "failed to parse question citation analysis")
 		}
 		platformID = normalizeMonitoringPlatformID(platformID)
@@ -4273,10 +4323,8 @@ func (s *MonitoringService) loadQuestionCitationAnalysis(ctx context.Context, te
 			}
 		}
 		item.CitationCount++
-		if platformID != "qwen" {
-			if _, ok := aliasIndex.Match(citedURL, normalizedURL); ok {
-				item.ContentCitationCount++
-			}
+		if platformID != "qwen" && sourceType.Valid && strings.TrimSpace(sourceType.String) != "" && sourceID.Valid {
+			item.ContentCitationCount++
 		}
 		aggregates[key] = item
 		totals[platformID]++
@@ -4311,16 +4359,11 @@ func (s *MonitoringService) loadQuestionContentCitations(ctx context.Context, te
 		return []MonitoringQuestionContentCitation{}, nil
 	}
 
-	aliasIndex, err := loadMonitoringPublishedAliasIndex(ctx, s.monitoringPool, tenantID)
-	if err != nil {
-		return nil, err
-	}
-
 	rows, err := s.monitoringPool.Query(ctx, `
 		SELECT
 			r.ai_platform_id,
-			cf.cited_url,
-			cf.normalized_url
+			cf.content_source_type,
+			cf.content_source_id
 		FROM question_monitor_runs r
 		JOIN monitoring_citation_facts cf
 			ON cf.tenant_id = r.tenant_id AND cf.run_id = r.id
@@ -4336,16 +4379,17 @@ func (s *MonitoringService) loadQuestionContentCitations(ctx context.Context, te
 
 	type contentCitationKey struct {
 		PlatformID string
-		ArticleID  int64
+		SourceType string
+		SourceID   int64
 	}
 
 	aggregates := make(map[contentCitationKey]MonitoringQuestionContentCitation)
 	totals := make(map[string]int64)
 	for rows.Next() {
 		var platformID string
-		var citedURL string
-		var normalizedURL string
-		if scanErr := rows.Scan(&platformID, &citedURL, &normalizedURL); scanErr != nil {
+		var sourceType sql.NullString
+		var sourceID sql.NullInt64
+		if scanErr := rows.Scan(&platformID, &sourceType, &sourceID); scanErr != nil {
 			return nil, response.ErrInternal(50041, "scan_failed", "failed to parse content citations")
 		}
 		platformID = normalizeMonitoringPlatformID(platformID)
@@ -4353,22 +4397,22 @@ func (s *MonitoringService) loadQuestionContentCitations(ctx context.Context, te
 			continue
 		}
 		totals[platformID]++
-		alias, ok := aliasIndex.Match(citedURL, normalizedURL)
-		if !ok {
+		normalizedSourceType := strings.TrimSpace(sourceType.String)
+		if !sourceType.Valid || normalizedSourceType == "" || !sourceID.Valid || sourceID.Int64 <= 0 {
 			continue
 		}
 		key := contentCitationKey{
 			PlatformID: platformID,
-			ArticleID:  alias.ArticleID,
+			SourceType: normalizedSourceType,
+			SourceID:   sourceID.Int64,
 		}
 		item := aggregates[key]
-		if item.ArticleID == 0 {
+		if item.SourceID == 0 {
 			item = MonitoringQuestionContentCitation{
-				ArticleID:       alias.ArticleID,
-				ArticleTitle:    alias.ArticleTitle,
-				PublishPlatform: alias.PublishPlatform,
-				AIPlatformID:    platformID,
-				PlatformName:    platformDisplayName(platformID),
+				SourceType:   normalizedSourceType,
+				SourceID:     sourceID.Int64,
+				AIPlatformID: platformID,
+				PlatformName: platformDisplayName(platformID),
 			}
 		}
 		item.CitationCount++
@@ -4377,9 +4421,36 @@ func (s *MonitoringService) loadQuestionContentCitations(ctx context.Context, te
 	if err := rows.Err(); err != nil {
 		return nil, response.ErrInternal(50041, "scan_failed", "failed to iterate content citations")
 	}
+	if len(aggregates) == 0 {
+		return []MonitoringQuestionContentCitation{}, nil
+	}
+
+	sourceRows := make([]monitoringCitedArticleSourceRow, 0, len(aggregates))
+	for key := range aggregates {
+		sourceRows = append(sourceRows, monitoringCitedArticleSourceRow{
+			SourceType: key.SourceType,
+			SourceID:   key.SourceID,
+		})
+	}
+	metaByKey, err := s.loadCitedArticleSourceMeta(ctx, tenantID, sourceRows)
+	if err != nil {
+		return nil, err
+	}
 
 	items := make([]MonitoringQuestionContentCitation, 0, len(aggregates))
-	for _, item := range aggregates {
+	for key, item := range aggregates {
+		if meta := metaByKey[monitoringContentSourceKey(key.SourceType, key.SourceID)]; meta.SourceID > 0 {
+			item.ArticleID = meta.ArticleID
+			item.ArticleTitle = meta.ArticleTitle
+			item.PublishPlatform = meta.PublishPlatform
+			item.SourceURL = meta.SourceURL
+		}
+		if strings.TrimSpace(item.ArticleTitle) == "" {
+			item.ArticleTitle = "未命名文章"
+		}
+		if strings.TrimSpace(item.PublishPlatform) == "" {
+			item.PublishPlatform = "外部文章"
+		}
 		item.CitationRate = divideAsPointer(item.CitationCount, totals[item.AIPlatformID])
 		items = append(items, item)
 	}
@@ -4390,7 +4461,10 @@ func (s *MonitoringService) loadQuestionContentCitations(ctx context.Context, te
 		if items[left].CitationCount != items[right].CitationCount {
 			return items[left].CitationCount > items[right].CitationCount
 		}
-		return items[left].ArticleID < items[right].ArticleID
+		if items[left].SourceType != items[right].SourceType {
+			return items[left].SourceType < items[right].SourceType
+		}
+		return items[left].SourceID < items[right].SourceID
 	})
 
 	return items, nil
diff --git a/server/internal/tenant/transport/monitoring_handler.go b/server/internal/tenant/transport/monitoring_handler.go
index f7762bb..541ba54 100644
--- a/server/internal/tenant/transport/monitoring_handler.go
+++ b/server/internal/tenant/transport/monitoring_handler.go
@@ -25,6 +25,12 @@ type monitoringCollectNowRequest struct {
 	TargetClientID       *string  `json:"target_client_id"`
 }
 
+type monitoringMarkedArticleRequest struct {
+	ArticleTitle string `json:"article_title"`
+	OriginalURL  string `json:"original_url"`
+	BrandID      *int64 `json:"brand_id"`
+}
+
 func NewMonitoringHandler(a *bootstrap.App) *MonitoringHandler {
 	return &MonitoringHandler{
 		svc: a.MonitoringService,
@@ -178,6 +184,86 @@ func (h *MonitoringHandler) CollectNow(c *gin.Context) {
 	response.Success(c, data)
 }
 
+func (h *MonitoringHandler) ListMarkedArticles(c *gin.Context) {
+	page, err := parseOptionalInt(c.Query("page"))
+	if err != nil {
+		response.Error(c, response.ErrBadRequest(40031, "invalid_page", "page must be a number"))
+		return
+	}
+	pageSize, err := parseOptionalInt(c.Query("page_size"))
+	if err != nil {
+		response.Error(c, response.ErrBadRequest(40031, "invalid_page_size", "page_size must be a number"))
+		return
+	}
+	data, svcErr := h.svc.ListMarkedArticles(c.Request.Context(), app.MonitoringMarkedArticleListParams{
+		Domain:      c.Query("domain"),
+		Title:       c.Query("title"),
+		CreatedFrom: c.Query("created_from"),
+		CreatedTo:   c.Query("created_to"),
+		Page:        page,
+		PageSize:    pageSize,
+	})
+	if svcErr != nil {
+		response.Error(c, svcErr)
+		return
+	}
+	response.Success(c, data)
+}
+
+func (h *MonitoringHandler) CreateMarkedArticle(c *gin.Context) {
+	var req monitoringMarkedArticleRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		response.Error(c, response.ErrBadRequest(40031, "invalid_marked_article_request", "marked article request is invalid"))
+		return
+	}
+	data, svcErr := h.svc.CreateMarkedArticle(c.Request.Context(), app.MonitoringMarkedArticleRequest{
+		ArticleTitle: req.ArticleTitle,
+		OriginalURL:  req.OriginalURL,
+		BrandID:      req.BrandID,
+	})
+	if svcErr != nil {
+		response.Error(c, svcErr)
+		return
+	}
+	response.Success(c, data)
+}
+
+func (h *MonitoringHandler) UpdateMarkedArticle(c *gin.Context) {
+	id, err := strconv.ParseInt(c.Param("id"), 10, 64)
+	if err != nil {
+		response.Error(c, response.ErrBadRequest(40031, "invalid_marked_article_id", "marked article id must be a number"))
+		return
+	}
+	var req monitoringMarkedArticleRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		response.Error(c, response.ErrBadRequest(40031, "invalid_marked_article_request", "marked article request is invalid"))
+		return
+	}
+	data, svcErr := h.svc.UpdateMarkedArticle(c.Request.Context(), id, app.MonitoringMarkedArticleRequest{
+		ArticleTitle: req.ArticleTitle,
+		OriginalURL:  req.OriginalURL,
+		BrandID:      req.BrandID,
+	})
+	if svcErr != nil {
+		response.Error(c, svcErr)
+		return
+	}
+	response.Success(c, data)
+}
+
+func (h *MonitoringHandler) DeleteMarkedArticle(c *gin.Context) {
+	id, err := strconv.ParseInt(c.Param("id"), 10, 64)
+	if err != nil {
+		response.Error(c, response.ErrBadRequest(40031, "invalid_marked_article_id", "marked article id must be a number"))
+		return
+	}
+	if svcErr := h.svc.DeleteMarkedArticle(c.Request.Context(), id); svcErr != nil {
+		response.Error(c, svcErr)
+		return
+	}
+	response.Success(c, gin.H{"ok": true})
+}
+
 func parseOptionalInt64(raw string) (int64, error) {
 	if raw == "" {
 		return 0, nil
diff --git a/server/internal/tenant/transport/router.go b/server/internal/tenant/transport/router.go
index 5772a1e..11c067d 100644
--- a/server/internal/tenant/transport/router.go
+++ b/server/internal/tenant/transport/router.go
@@ -257,6 +257,10 @@ func RegisterRoutes(app *bootstrap.App) {
 	monitoringHandler := NewMonitoringHandler(app)
 	monitoring.GET("/dashboard/composite", monitoringHandler.DashboardComposite)
 	monitoring.GET("/citation-summary", monitoringHandler.CitationSummary)
+	monitoring.GET("/marked-articles", monitoringHandler.ListMarkedArticles)
+	monitoring.POST("/marked-articles", monitoringHandler.CreateMarkedArticle)
+	monitoring.PUT("/marked-articles/:id", monitoringHandler.UpdateMarkedArticle)
+	monitoring.DELETE("/marked-articles/:id", monitoringHandler.DeleteMarkedArticle)
 	monitoring.GET("/brands/:brand_id/questions/:question_id/detail", monitoringHandler.QuestionDetail)
 	monitoring.POST("/brands/:brand_id/collect-now", monitoringHandler.CollectNow)
 
diff --git a/server/internal/tenant/transport/router_test.go b/server/internal/tenant/transport/router_test.go
index 2e1a29d..11663c4 100644
--- a/server/internal/tenant/transport/router_test.go
+++ b/server/internal/tenant/transport/router_test.go
@@ -42,6 +42,10 @@ func TestProtectedRoutes_RequireAuth(t *testing.T) {
 		{http.MethodGet, "/api/tenant/brands"},
 		{http.MethodGet, "/api/tenant/brands/library-summary"},
 		{http.MethodGet, "/api/tenant/monitoring/brands/:brand_id/questions/:question_id/detail"},
+		{http.MethodGet, "/api/tenant/monitoring/marked-articles"},
+		{http.MethodPost, "/api/tenant/monitoring/marked-articles"},
+		{http.MethodPut, "/api/tenant/monitoring/marked-articles/:id"},
+		{http.MethodDelete, "/api/tenant/monitoring/marked-articles/:id"},
 		{http.MethodPost, "/api/tenant/brands"},
 	}
 
diff --git a/server/migrations_monitoring/20260617113000_create_user_marked_cited_articles.down.sql b/server/migrations_monitoring/20260617113000_create_user_marked_cited_articles.down.sql
new file mode 100644
index 0000000..8853c96
--- /dev/null
+++ b/server/migrations_monitoring/20260617113000_create_user_marked_cited_articles.down.sql
@@ -0,0 +1,7 @@
+DROP INDEX IF EXISTS idx_monitoring_citation_facts_content_source;
+
+ALTER TABLE monitoring_citation_facts
+    DROP COLUMN IF EXISTS content_source_id,
+    DROP COLUMN IF EXISTS content_source_type;
+
+DROP TABLE IF EXISTS monitoring_user_marked_articles;
diff --git a/server/migrations_monitoring/20260617113000_create_user_marked_cited_articles.up.sql b/server/migrations_monitoring/20260617113000_create_user_marked_cited_articles.up.sql
new file mode 100644
index 0000000..6e3f582
--- /dev/null
+++ b/server/migrations_monitoring/20260617113000_create_user_marked_cited_articles.up.sql
@@ -0,0 +1,41 @@
+CREATE TABLE IF NOT EXISTS monitoring_user_marked_articles (
+    id                 BIGSERIAL PRIMARY KEY,
+    tenant_id          BIGINT NOT NULL,
+    brand_id           BIGINT,
+    marked_by_user_id  BIGINT,
+    article_title      TEXT NOT NULL,
+    original_url       TEXT NOT NULL,
+    normalized_url     TEXT NOT NULL,
+    host               VARCHAR(255) NOT NULL,
+    registrable_domain VARCHAR(255) NOT NULL,
+    site_key           VARCHAR(255) NOT NULL,
+    last_path_segment  VARCHAR(255),
+    publish_platform   VARCHAR(100) NOT NULL DEFAULT '外部文章',
+    marked_at          TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    expires_at         TIMESTAMPTZ NOT NULL DEFAULT (NOW() + INTERVAL '6 months'),
+    created_at         TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    updated_at         TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS uk_monitoring_user_marked_article_url
+    ON monitoring_user_marked_articles(tenant_id, normalized_url);
+
+CREATE INDEX IF NOT EXISTS idx_monitoring_user_marked_articles_domain
+    ON monitoring_user_marked_articles(tenant_id, registrable_domain, created_at DESC, id DESC);
+
+CREATE INDEX IF NOT EXISTS idx_monitoring_user_marked_articles_title
+    ON monitoring_user_marked_articles USING GIN (to_tsvector('simple', article_title));
+
+CREATE INDEX IF NOT EXISTS idx_monitoring_user_marked_articles_created
+    ON monitoring_user_marked_articles(tenant_id, created_at DESC, id DESC);
+
+CREATE INDEX IF NOT EXISTS idx_monitoring_user_marked_articles_expires
+    ON monitoring_user_marked_articles(expires_at, id);
+
+ALTER TABLE monitoring_citation_facts
+    ADD COLUMN IF NOT EXISTS content_source_type VARCHAR(30),
+    ADD COLUMN IF NOT EXISTS content_source_id BIGINT;
+
+CREATE INDEX IF NOT EXISTS idx_monitoring_citation_facts_content_source
+    ON monitoring_citation_facts(tenant_id, content_source_type, content_source_id)
+    WHERE content_source_type IS NOT NULL AND content_source_id IS NOT NULL;
diff --git a/server/migrations_monitoring/20260617124500_optimize_monitoring_content_citations.down.sql b/server/migrations_monitoring/20260617124500_optimize_monitoring_content_citations.down.sql
new file mode 100644
index 0000000..3599dc3
--- /dev/null
+++ b/server/migrations_monitoring/20260617124500_optimize_monitoring_content_citations.down.sql
@@ -0,0 +1,5 @@
+DROP INDEX IF EXISTS idx_article_url_alias_article_lookup;
+DROP INDEX IF EXISTS idx_citation_facts_content_window;
+DROP INDEX IF EXISTS idx_citation_facts_normalized_url;
+DROP INDEX IF EXISTS idx_citation_facts_tenant_run;
+DROP INDEX IF EXISTS idx_monitor_runs_citation_summary;
diff --git a/server/migrations_monitoring/20260617124500_optimize_monitoring_content_citations.up.sql b/server/migrations_monitoring/20260617124500_optimize_monitoring_content_citations.up.sql
new file mode 100644
index 0000000..2d12f7a
--- /dev/null
+++ b/server/migrations_monitoring/20260617124500_optimize_monitoring_content_citations.up.sql
@@ -0,0 +1,63 @@
+CREATE INDEX IF NOT EXISTS idx_monitor_runs_citation_summary
+    ON question_monitor_runs (
+        tenant_id,
+        brand_id,
+        collector_type,
+        status,
+        business_date,
+        question_id,
+        ai_platform_id,
+        id
+    );
+
+CREATE INDEX IF NOT EXISTS idx_citation_facts_tenant_run
+    ON monitoring_citation_facts(tenant_id, run_id);
+
+CREATE INDEX IF NOT EXISTS idx_citation_facts_normalized_url
+    ON monitoring_citation_facts(tenant_id, normalized_url);
+
+CREATE INDEX IF NOT EXISTS idx_citation_facts_content_window
+    ON monitoring_citation_facts (
+        tenant_id,
+        brand_id,
+        business_date,
+        ai_platform_id,
+        content_source_type,
+        content_source_id,
+        run_id
+    )
+    WHERE content_source_type IS NOT NULL AND content_source_id IS NOT NULL;
+
+CREATE INDEX IF NOT EXISTS idx_article_url_alias_article_lookup
+    ON monitoring_article_url_aliases(tenant_id, article_id, updated_at DESC, id DESC)
+    WHERE confidence = 'high';
+
+UPDATE monitoring_citation_facts cf
+SET content_source_type = 'published_article',
+    content_source_id = alias.article_id
+FROM monitoring_article_url_aliases alias
+WHERE alias.tenant_id = cf.tenant_id
+  AND alias.normalized_url = cf.normalized_url
+  AND alias.confidence = 'high'
+  AND alias.article_id IS NOT NULL
+  AND (
+    cf.content_source_type IS DISTINCT FROM 'published_article'
+    OR cf.content_source_id IS DISTINCT FROM alias.article_id
+  );
+
+UPDATE monitoring_citation_facts
+SET content_source_type = 'published_article',
+    content_source_id = article_id
+WHERE content_source_type IS NULL
+  AND content_source_id IS NULL
+  AND article_id IS NOT NULL;
+
+UPDATE monitoring_citation_facts cf
+SET content_source_type = 'manual_mark',
+    content_source_id = marked.id
+FROM monitoring_user_marked_articles marked
+WHERE marked.tenant_id = cf.tenant_id
+  AND marked.normalized_url = cf.normalized_url
+  AND marked.expires_at > NOW()
+  AND cf.content_source_type IS NULL
+  AND cf.content_source_id IS NULL;
diff --git a/server/migrations_monitoring/20260617132000_tune_external_article_citation_indexes.down.sql b/server/migrations_monitoring/20260617132000_tune_external_article_citation_indexes.down.sql
new file mode 100644
index 0000000..2ff2af7
--- /dev/null
+++ b/server/migrations_monitoring/20260617132000_tune_external_article_citation_indexes.down.sql
@@ -0,0 +1,7 @@
+DROP INDEX IF EXISTS idx_marked_articles_title_trgm;
+DROP INDEX IF EXISTS idx_marked_articles_domain_trgm;
+DROP INDEX IF EXISTS idx_citation_facts_day_content_run;
+DROP INDEX IF EXISTS idx_citation_facts_run_content;
+
+CREATE INDEX IF NOT EXISTS idx_monitoring_user_marked_articles_title
+    ON monitoring_user_marked_articles USING GIN (to_tsvector('simple', article_title));
diff --git a/server/migrations_monitoring/20260617132000_tune_external_article_citation_indexes.up.sql b/server/migrations_monitoring/20260617132000_tune_external_article_citation_indexes.up.sql
new file mode 100644
index 0000000..b608526
--- /dev/null
+++ b/server/migrations_monitoring/20260617132000_tune_external_article_citation_indexes.up.sql
@@ -0,0 +1,44 @@
+CREATE EXTENSION IF NOT EXISTS pg_trgm;
+
+CREATE INDEX IF NOT EXISTS idx_citation_facts_run_content
+    ON monitoring_citation_facts (
+        tenant_id,
+        run_id,
+        content_source_type,
+        content_source_id
+    )
+    WHERE content_source_type IS NOT NULL AND content_source_id IS NOT NULL;
+
+CREATE INDEX IF NOT EXISTS idx_citation_facts_day_content_run
+    ON monitoring_citation_facts (
+        tenant_id,
+        brand_id,
+        business_date,
+        ai_platform_id,
+        run_id,
+        content_source_type,
+        content_source_id
+    )
+    WHERE content_source_type IS NOT NULL AND content_source_id IS NOT NULL;
+
+CREATE INDEX IF NOT EXISTS idx_marked_articles_domain_trgm
+    ON monitoring_user_marked_articles
+    USING GIN (
+        lower(registrable_domain) gin_trgm_ops,
+        lower(host) gin_trgm_ops,
+        lower(site_key) gin_trgm_ops
+    );
+
+DROP INDEX IF EXISTS idx_monitoring_user_marked_articles_title;
+
+CREATE INDEX IF NOT EXISTS idx_marked_articles_title_trgm
+    ON monitoring_user_marked_articles
+    USING GIN (lower(article_title) gin_trgm_ops);
+
+ALTER TABLE monitoring_user_marked_articles
+    ALTER COLUMN publish_platform SET DEFAULT '外部文章';
+
+UPDATE monitoring_user_marked_articles
+SET publish_platform = '外部文章',
+    updated_at = NOW()
+WHERE publish_platform IN ('自有文章', 'Own Article', 'Owned Article', 'Manual Article');
diff --git a/server/migrations_monitoring/20260617133500_tune_marked_article_domain_lookup.down.sql b/server/migrations_monitoring/20260617133500_tune_marked_article_domain_lookup.down.sql
new file mode 100644
index 0000000..f6f0748
--- /dev/null
+++ b/server/migrations_monitoring/20260617133500_tune_marked_article_domain_lookup.down.sql
@@ -0,0 +1,10 @@
+DROP INDEX IF EXISTS idx_marked_articles_site_key_lookup;
+DROP INDEX IF EXISTS idx_marked_articles_host_lookup;
+
+CREATE INDEX IF NOT EXISTS idx_marked_articles_domain_trgm
+    ON monitoring_user_marked_articles
+    USING GIN (
+        lower(registrable_domain) gin_trgm_ops,
+        lower(host) gin_trgm_ops,
+        lower(site_key) gin_trgm_ops
+    );
diff --git a/server/migrations_monitoring/20260617133500_tune_marked_article_domain_lookup.up.sql b/server/migrations_monitoring/20260617133500_tune_marked_article_domain_lookup.up.sql
new file mode 100644
index 0000000..08a3a49
--- /dev/null
+++ b/server/migrations_monitoring/20260617133500_tune_marked_article_domain_lookup.up.sql
@@ -0,0 +1,7 @@
+DROP INDEX IF EXISTS idx_marked_articles_domain_trgm;
+
+CREATE INDEX IF NOT EXISTS idx_marked_articles_host_lookup
+    ON monitoring_user_marked_articles(tenant_id, host, created_at DESC, id DESC);
+
+CREATE INDEX IF NOT EXISTS idx_marked_articles_site_key_lookup
+    ON monitoring_user_marked_articles(tenant_id, site_key, created_at DESC, id DESC);
diff --git a/server/migrations_ops/20260617134500_document_external_article_retention_job.down.sql b/server/migrations_ops/20260617134500_document_external_article_retention_job.down.sql
new file mode 100644
index 0000000..8f9c9eb
--- /dev/null
+++ b/server/migrations_ops/20260617134500_document_external_article_retention_job.down.sql
@@ -0,0 +1,6 @@
+UPDATE ops.scheduler_jobs
+SET display_name = '监控历史保留清理',
+    description = '按保留窗口和索引限批删除最近 30 天以前的监控历史数据。',
+    config = config - 'external_article_mark_retention' - 'clears_manual_mark_attribution',
+    updated_at = NOW()
+WHERE job_key = 'monitoring_retention_cleanup';
diff --git a/server/migrations_ops/20260617134500_document_external_article_retention_job.up.sql b/server/migrations_ops/20260617134500_document_external_article_retention_job.up.sql
new file mode 100644
index 0000000..aeeb3aa
--- /dev/null
+++ b/server/migrations_ops/20260617134500_document_external_article_retention_job.up.sql
@@ -0,0 +1,6 @@
+UPDATE ops.scheduler_jobs
+SET display_name = '监控历史与外部文章标记清理',
+    description = '按保留窗口和索引限批删除监控历史；外部文章标记到期 6 个月后删除，并同步清理引用事实归因。',
+    config = config || '{"external_article_mark_retention":"6 months","clears_manual_mark_attribution":true}'::jsonb,
+    updated_at = NOW()
+WHERE job_key = 'monitoring_retention_cleanup';