diff --git a/src/apps/parsers/source_registry.py b/src/apps/parsers/source_registry.py
index 8843a8c..744a2cc 100644
--- a/src/apps/parsers/source_registry.py
+++ b/src/apps/parsers/source_registry.py
@@ -31,12 +31,12 @@ class ParserSourceDescriptor:
     @property
     def result_list_url(self) -> str:
         """Frontend/API URL для списка результата источника."""
-        return f"/api/v1/{self.api_route}/" if self.api_route else ""
+        return f"/api/v1/parsers/results/{self.key}/" if self.api_route else ""
 
     @property
     def result_detail_url(self) -> str:
         """Frontend/API URL для карточки результата источника."""
-        return f"/api/v1/{self.api_route}/{{id}}/" if self.api_route else ""
+        return f"/api/v1/parsers/results/{self.key}/{{id}}/" if self.api_route else ""
 
     @property
     def upload_url(self) -> str:
diff --git a/src/apps/parsers/urls.py b/src/apps/parsers/urls.py
index 493680a..609705a 100644
--- a/src/apps/parsers/urls.py
+++ b/src/apps/parsers/urls.py
@@ -26,6 +26,8 @@ from apps.parsers.views import (
     SourceCardDetailView,
     SourceCardListView,
     SourceCardRefreshView,
+    SourceResultDetailView,
+    SourceResultListView,
     SourceTaskStatusListView,
 )
 from django.urls import include, path
@@ -134,6 +136,16 @@ urlpatterns = [
         ParserUploadView.as_view(),
         name="upload-parser-data",
     ),
+    path(
+        "results/<str:source_key>/",
+        SourceResultListView.as_view(),
+        name="source-result-list",
+    ),
+    path(
+        "results/<str:source_key>/<int:pk>/",
+        SourceResultDetailView.as_view(),
+        name="source-result-detail",
+    ),
     path(
         "schedules/",
         ParserScheduleListCreateView.as_view(),
diff --git a/src/apps/parsers/views.py b/src/apps/parsers/views.py
index db5e2b2..f6ace39 100644
--- a/src/apps/parsers/views.py
+++ b/src/apps/parsers/views.py
@@ -145,6 +145,7 @@ NATIVE_RECORD_MODELS = {
     ParserLoadLog.Source.MANUFACTURES: ManufacturerRecord,
     ParserLoadLog.Source.INSPECTIONS: InspectionRecord,
     ParserLoadLog.Source.PROCUREMENTS: ProcurementRecord,
+    ParserLoadLog.Source.FNS_REPORTS: FinancialReport,
 }
 EXISTING_TASK_PARAMS = {
     "industrial": {"proxies", "requested_by_id"},
@@ -1457,6 +1458,15 @@ def _native_record_to_result(
         url = record.href
         inn = record.customer_inn
         ogrn = record.customer_ogrn
+    elif source == ParserLoadLog.Source.FNS_REPORTS:
+        external_id = record.external_id
+        organisation_name = ""
+        title = record.file_name
+        record_date = ""
+        status_value = record.status
+        url = ""
+        inn = ""
+        ogrn = record.ogrn
     else:
         external_id = record.registration_number
         organisation_name = record.organisation_name
@@ -1641,6 +1651,14 @@ def _native_field_map(source: str) -> dict[str, str]:
             "record_date": "publish_date",
             "status": "status",
         }
+    if source == ParserLoadLog.Source.FNS_REPORTS:
+        return {
+            **common,
+            "external_id": "external_id",
+            "ogrn": "ogrn",
+            "title": "file_name",
+            "status": "status",
+        }
     return {
         **common,
         "external_id": "registration_number",
@@ -1681,6 +1699,13 @@ def _native_search_q(source: str, search: str) -> Q:
             | Q(customer_name__icontains=search)
             | Q(customer_inn__icontains=search)
         )
+    if source == ParserLoadLog.Source.FNS_REPORTS:
+        return (
+            Q(file_name__icontains=search)
+            | Q(external_id__icontains=search)
+            | Q(ogrn__icontains=search)
+            | Q(status__icontains=search)
+        )
     return (
         Q(organisation_name__icontains=search)
         | Q(registration_number__icontains=search)
diff --git a/src/settings/dev.py b/src/settings/dev.py
index c5dac60..2cd49f9 100644
--- a/src/settings/dev.py
+++ b/src/settings/dev.py
@@ -22,6 +22,19 @@ STATE_CORP_EXCHANGE_TOKEN = os.getenv(
 # JWT
 SIMPLE_JWT["SIGNING_KEY"] = SECRET_KEY
 
+# Dev frontend can run from any workstation/port in the local network.
+# Production keeps the restrictive CORS/CSRF policy from settings.production.
+CORS_ALLOW_ALL_ORIGINS = True
+CORS_ALLOW_CREDENTIALS = True
+CORS_ALLOW_PRIVATE_NETWORK = True
+CSRF_COOKIE_SECURE = False
+SESSION_COOKIE_SECURE = False
+MIDDLEWARE = [
+    middleware
+    for middleware in MIDDLEWARE
+    if middleware != "django.middleware.csrf.CsrfViewMiddleware"
+]
+
 
 def _normalize_local_host(host: str) -> str:
     """Нормализует host для локального запуска backend на хосте."""
diff --git a/src/templates/dashboard.html b/src/templates/dashboard.html
index c9c22ed..2da3874 100644
--- a/src/templates/dashboard.html
+++ b/src/templates/dashboard.html
@@ -1,9 +1,11 @@
 <!doctype html>
-<html lang="ru">
+<html lang="ru" class="dark">
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width, initial-scale=1">
   <title>Mostovik Parser Dashboard</title>
+  <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/element-plus@2/dist/index.css">
+  <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/element-plus@2/theme-chalk/dark/css-vars.css">
   <style>
     :root {
       color-scheme: dark;
@@ -107,6 +109,32 @@
     button:hover { background: var(--accent-strong); border-color: var(--accent-strong); }
     button.secondary { background: var(--field); color: var(--accent); }
     button.secondary:hover { background: var(--panel-soft); }
+    button.icon-button {
+      width: 36px;
+      min-width: 36px;
+      min-height: 34px;
+      padding: 0;
+      display: inline-grid;
+      place-items: center;
+      border-radius: 8px;
+    }
+    button.icon-button svg {
+      width: 17px;
+      height: 17px;
+      stroke: currentColor;
+      stroke-width: 2;
+      stroke-linecap: round;
+      stroke-linejoin: round;
+      fill: none;
+      pointer-events: none;
+    }
+    button.icon-button.danger {
+      background: rgb(224 108 117 / 14%);
+      color: var(--danger);
+    }
+    button.icon-button.danger:hover {
+      background: rgb(224 108 117 / 24%);
+    }
     button.ghost {
       border-color: transparent;
       background: transparent;
@@ -119,6 +147,17 @@
     }
     button.danger { border-color: var(--danger); background: var(--danger); color: #1b1012; }
     button:disabled { opacity: .55; cursor: not-allowed; }
+    .sr-only {
+      position: absolute;
+      width: 1px;
+      height: 1px;
+      padding: 0;
+      margin: -1px;
+      overflow: hidden;
+      clip: rect(0, 0, 0, 0);
+      white-space: nowrap;
+      border: 0;
+    }
     pre {
       margin: 0;
       padding: 10px;
@@ -287,6 +326,9 @@
       grid-template-columns: minmax(0, 1.15fr) minmax(300px, .85fr);
       gap: 16px;
     }
+    .chart-grid-full {
+      grid-template-columns: 1fr;
+    }
     .chart-panel {
       border: 1px solid var(--line);
       border-radius: 8px;
@@ -355,6 +397,51 @@
       padding: 9px;
     }
     .mode-pill strong { display: block; font-size: 18px; }
+    .registry-analytics {
+      display: grid;
+      grid-template-columns: minmax(220px, .9fr) minmax(0, 1.5fr);
+      gap: 14px;
+      align-items: stretch;
+    }
+    .registry-score-card {
+      border: 1px solid var(--line);
+      border-radius: 8px;
+      background: var(--field);
+      padding: 12px;
+      display: grid;
+      gap: 10px;
+      align-content: start;
+    }
+    .registry-score-card strong {
+      font-size: 26px;
+      color: #f1f3f7;
+    }
+    .registry-bars {
+      display: grid;
+      gap: 10px;
+    }
+    .registry-bar-row {
+      display: grid;
+      grid-template-columns: minmax(280px, .9fr) minmax(240px, 1.3fr) 96px;
+      gap: 10px;
+      align-items: center;
+    }
+    .registry-bar-row strong,
+    .registry-bar-row span {
+      min-width: 0;
+    }
+    .registry-bar-title {
+      display: grid;
+      gap: 2px;
+    }
+    .registry-bar-title strong {
+      overflow: hidden;
+      text-overflow: ellipsis;
+      white-space: nowrap;
+    }
+    .registry-bar-value {
+      text-align: right;
+    }
 
     .source-list {
       display: grid;
@@ -523,9 +610,106 @@
       font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
     }
     #sourceTableView {
-      min-height: 420px;
+      min-height: 650px;
       overflow-x: auto;
     }
+    [v-cloak] {
+      display: none;
+    }
+    .source-records-app {
+      min-height: 650px;
+    }
+    .source-records-card {
+      display: grid;
+      gap: 12px;
+      min-height: 650px;
+    }
+    .source-records-table-wrap {
+      min-height: 560px;
+      border: 1px solid var(--line);
+      border-radius: 8px;
+      overflow: hidden;
+      background: var(--panel);
+    }
+    .source-records-footer {
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      gap: 12px;
+      min-height: 40px;
+      flex-wrap: wrap;
+    }
+    .route-record-title,
+    .route-record-secondary,
+    .route-record-cell {
+      display: block;
+      min-width: 0;
+      overflow: hidden;
+      text-overflow: ellipsis;
+      white-space: nowrap;
+    }
+    .route-record-title {
+      color: #eef2f7;
+      font-weight: 650;
+    }
+    .route-record-secondary {
+      margin-top: 3px;
+      color: var(--muted);
+      font-size: 12px;
+    }
+    .source-record-detail {
+      display: grid;
+      gap: 12px;
+      min-height: 650px;
+      align-content: start;
+    }
+    .source-record-detail pre {
+      min-height: 340px;
+      max-height: 62vh;
+    }
+    .el-table {
+      --el-table-bg-color: var(--panel);
+      --el-table-tr-bg-color: var(--panel);
+      --el-table-header-bg-color: #242932;
+      --el-table-header-text-color: var(--muted);
+      --el-table-text-color: var(--text);
+      --el-table-row-hover-bg-color: rgb(97 175 239 / 10%);
+      --el-table-border-color: var(--line);
+      --el-table-border: 1px solid var(--line);
+      font-size: 13px;
+    }
+    .el-table .cell {
+      line-height: 1.35;
+    }
+    .el-table__empty-block {
+      min-height: 520px;
+    }
+    .el-loading-mask {
+      background-color: rgb(40 44 52 / 70%);
+    }
+    .el-pagination {
+      --el-pagination-bg-color: transparent;
+      --el-pagination-button-bg-color: var(--field);
+      --el-pagination-button-color: var(--text);
+      --el-pagination-hover-color: var(--accent);
+      --el-pagination-button-disabled-bg-color: var(--panel-soft);
+      --el-text-color-regular: var(--text);
+      --el-text-color-primary: var(--text);
+    }
+    .el-pagination .el-select {
+      width: 112px;
+    }
+    .el-select__wrapper,
+    .el-input__wrapper {
+      background: var(--field);
+      border: 1px solid var(--line);
+      box-shadow: none;
+    }
+    .el-select__wrapper.is-focused,
+    .el-input__wrapper.is-focus {
+      border-color: var(--accent);
+      box-shadow: 0 0 0 2px rgb(97 175 239 / 20%);
+    }
     .empty-state {
       padding: 18px;
       border: 1px dashed var(--line-strong);
@@ -643,9 +827,11 @@
       background: rgb(97 175 239 / 15%);
       color: var(--accent);
     }
+    .method-chip.get { background: rgb(152 195 121 / 15%); color: var(--ok); }
     .method-chip.post { background: rgb(198 120 221 / 15%); color: var(--violet); }
     .method-chip.patch { background: rgb(229 192 123 / 15%); color: var(--warn); }
     .method-chip.delete { background: rgb(224 108 117 / 15%); color: var(--danger); }
+    .method-chip.options { background: rgb(86 182 194 / 15%); color: var(--cyan); }
     details {
       border: 1px solid var(--line);
       border-radius: 7px;
@@ -707,10 +893,145 @@
       gap: 10px;
       margin: 12px 0;
     }
+    .schedule-table {
+      table-layout: fixed;
+    }
+    .schedule-table th:nth-child(1),
+    .schedule-table td:nth-child(1) { width: 30%; }
+    .schedule-table th:nth-child(2),
+    .schedule-table td:nth-child(2) { width: 43%; }
+    .schedule-table th:nth-child(3),
+    .schedule-table td:nth-child(3) { width: 14%; }
+    .schedule-table th:nth-child(4),
+    .schedule-table td:nth-child(4) { width: 112px; }
+    .schedule-source {
+      display: grid;
+      gap: 3px;
+      min-width: 0;
+    }
+    .schedule-source strong,
+    .schedule-source span {
+      overflow: hidden;
+      text-overflow: ellipsis;
+    }
+    .schedule-plan {
+      display: grid;
+      grid-template-columns: 34px minmax(0, 1fr);
+      gap: 10px;
+      align-items: center;
+    }
+    .schedule-plan-icon {
+      width: 34px;
+      height: 34px;
+      border: 1px solid rgb(97 175 239 / 34%);
+      border-radius: 8px;
+      display: grid;
+      place-items: center;
+      background: rgb(97 175 239 / 10%);
+      color: var(--accent);
+    }
+    .schedule-plan-icon svg {
+      width: 18px;
+      height: 18px;
+      stroke: currentColor;
+      stroke-width: 2;
+      stroke-linecap: round;
+      stroke-linejoin: round;
+      fill: none;
+    }
+    .schedule-plan-text {
+      display: grid;
+      gap: 2px;
+      min-width: 0;
+    }
+    .schedule-plan-text strong,
+    .schedule-plan-text span {
+      min-width: 0;
+      overflow: hidden;
+      text-overflow: ellipsis;
+    }
+    .schedule-actions {
+      display: flex;
+      gap: 6px;
+      justify-content: flex-end;
+    }
+    .endpoint-toolbar {
+      display: flex;
+      flex-wrap: wrap;
+      align-items: center;
+      justify-content: space-between;
+      gap: 12px;
+      margin-bottom: 14px;
+    }
+    .endpoint-table {
+      table-layout: fixed;
+    }
+    .endpoint-table th:nth-child(1),
+    .endpoint-table td:nth-child(1) { width: 13%; }
+    .endpoint-table th:nth-child(2),
+    .endpoint-table td:nth-child(2) { width: 12%; }
+    .endpoint-table th:nth-child(3),
+    .endpoint-table td:nth-child(3) { width: 34%; }
+    .endpoint-table th:nth-child(4),
+    .endpoint-table td:nth-child(4) { width: 18%; }
+    .endpoint-table th:nth-child(5),
+    .endpoint-table td:nth-child(5) { width: 10%; }
+    .endpoint-table th:nth-child(6),
+    .endpoint-table td:nth-child(6) { width: 13%; }
+    .endpoint-title {
+      display: grid;
+      gap: 3px;
+      min-width: 0;
+    }
+    .endpoint-title strong,
+    .endpoint-title span,
+    .endpoint-url {
+      min-width: 0;
+      overflow: hidden;
+      text-overflow: ellipsis;
+      white-space: nowrap;
+    }
+    .endpoint-url {
+      display: block;
+      font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+      font-size: 12px;
+      color: var(--text);
+    }
+    .endpoint-result-list {
+      display: grid;
+      gap: 10px;
+    }
+    .endpoint-result {
+      border: 1px solid var(--line);
+      border-radius: 8px;
+      background: var(--field);
+      padding: 10px;
+      display: grid;
+      gap: 8px;
+    }
+    .endpoint-result header {
+      position: static;
+      padding: 0;
+      border: 0;
+      background: transparent;
+      display: flex;
+      justify-content: space-between;
+      gap: 10px;
+      align-items: flex-start;
+    }
+    .endpoint-result pre {
+      max-height: 170px;
+    }
+    .endpoint-actions {
+      display: flex;
+      gap: 6px;
+      justify-content: flex-end;
+    }
 
     @media (max-width: 1100px) {
       .kpi-grid { grid-template-columns: repeat(3, minmax(0, 1fr)); }
       .chart-grid { grid-template-columns: 1fr; }
+      .registry-analytics { grid-template-columns: 1fr; }
       .bar-row { grid-template-columns: minmax(120px, 1fr) minmax(120px, 1.4fr) 74px; }
     }
     @media (max-width: 760px) {
@@ -794,24 +1115,74 @@
         <button id="reloadRouteButton" class="secondary" type="button">Обновить данные</button>
       </div>
       <div id="sourceTableView">
-        <table class="table record-table">
-          <thead>
-            <tr>
-              <th>ID</th>
-              <th>Запись</th>
-              <th>ИНН / ОГРН</th>
-              <th>Дата</th>
-              <th>Статус</th>
-            </tr>
-          </thead>
-          <tbody id="recordsBody"></tbody>
-        </table>
-        <div id="recordsEmpty" class="empty-state hidden"></div>
-      </div>
-      <div id="itemDetailView" class="hidden">
-        <div id="itemFields" class="detail-grid"></div>
-        <h3>Payload</h3>
-        <pre id="itemPayload"></pre>
+        <div id="sourceRecordsApp" class="source-records-app" v-cloak>
+          <div v-if="mode === 'list'" class="source-records-card">
+            <div v-if="error" class="empty-state" v-text="error"></div>
+            <div class="source-records-table-wrap">
+              <el-table
+                :data="records"
+                :height="tableHeight"
+                :row-key="recordRowKey"
+                table-layout="fixed"
+                empty-text="По этому источнику записей пока нет. Запустите парсер или дождитесь завершения Celery-задачи."
+                v-loading="loading"
+                @row-click="openRecord"
+              >
+                <el-table-column prop="id" label="ID" width="86" fixed>
+                  <template v-slot:default="scope">
+                    <span class="mono route-record-cell" v-text="scope.row.id"></span>
+                  </template>
+                </el-table-column>
+                <el-table-column label="Запись" min-width="320">
+                  <template v-slot:default="scope">
+                    <span class="route-record-title" :title="recordLabel(scope.row)" v-text="recordLabel(scope.row)"></span>
+                    <span class="route-record-secondary mono" :title="recordExternalId(scope.row)" v-text="recordExternalId(scope.row)"></span>
+                  </template>
+                </el-table-column>
+                <el-table-column label="ИНН / ОГРН" min-width="220">
+                  <template v-slot:default="scope">
+                    <span class="route-record-cell" v-text="recordInn(scope.row)"></span>
+                    <span class="route-record-secondary" v-text="recordOgrn(scope.row)"></span>
+                  </template>
+                </el-table-column>
+                <el-table-column label="Дата" width="150">
+                  <template v-slot:default="scope">
+                    <span class="route-record-cell" v-text="recordDate(scope.row)"></span>
+                  </template>
+                </el-table-column>
+                <el-table-column label="Статус" width="170">
+                  <template v-slot:default="scope">
+                    <span class="route-record-cell" v-text="recordStatus(scope.row)"></span>
+                    <span class="route-record-secondary" v-text="recordAmount(scope.row)"></span>
+                  </template>
+                </el-table-column>
+              </el-table>
+            </div>
+            <div class="source-records-footer">
+              <span class="muted" v-text="footerText"></span>
+              <el-pagination
+                v-model:current-page="page"
+                v-model:page-size="pageSize"
+                :page-sizes="pageSizes"
+                :total="total"
+                layout="total, sizes, prev, pager, next"
+                @size-change="handlePageSizeChange"
+                @current-change="handlePageChange"
+              ></el-pagination>
+            </div>
+          </div>
+          <div v-else class="source-record-detail">
+            <div v-if="error" class="empty-state" v-text="error"></div>
+            <div class="detail-grid">
+              <div v-for="field in detailFields" :key="field.label" class="detail-field">
+                <span v-text="field.label"></span>
+                <span v-text="field.value || '-'"></span>
+              </div>
+            </div>
+            <h3>Payload</h3>
+            <pre v-text="detailPayload"></pre>
+          </div>
+        </div>
       </div>
     </section>
 
@@ -824,6 +1195,7 @@
         <nav class="tabs" aria-label="Разделы dashboard">
           <button class="tab-button active" data-main-tab="analytics" type="button">Аналитика</button>
           <button class="tab-button" data-main-tab="sources" type="button">Источники</button>
+          <button class="tab-button" data-main-tab="endpoints" type="button">Endpoints</button>
           <button class="tab-button" data-main-tab="uploads" type="button">Ручная загрузка</button>
           <button class="tab-button" data-main-tab="automation" type="button">Автозапуск</button>
         </nav>
@@ -849,6 +1221,15 @@
             <div id="modeBreakdown" class="mode-grid"></div>
           </div>
         </div>
+        <div class="chart-grid chart-grid-full">
+          <div class="chart-panel">
+            <div class="row">
+              <h2>Полнота данных по реестрам</h2>
+              <span class="badge info">организации</span>
+            </div>
+            <div id="registryCompletenessChart" class="registry-analytics"></div>
+          </div>
+        </div>
       </section>
 
       <section id="sourcesPanel" class="tab-panel hidden" data-tab-panel="sources">
@@ -862,6 +1243,40 @@
         <div id="sourceCards" class="source-list"></div>
       </section>
 
+      <section id="endpointsPanel" class="tab-panel hidden" data-tab-panel="endpoints">
+        <div class="section-head">
+          <div>
+            <h2>API endpoints</h2>
+            <p>Список рабочих endpoint-ов dashboard и parser API. Массовая проверка безопасно читает GET, а для мутаций использует OPTIONS.</p>
+          </div>
+          <span id="endpointCount" class="badge"></span>
+        </div>
+        <div class="endpoint-toolbar">
+          <div class="legend">
+            <span class="badge info">GET проверяется реальным запросом</span>
+            <span class="badge warn">POST/PATCH/DELETE проверяются через OPTIONS</span>
+            <span id="endpointCheckSummary" class="muted">Проверка еще не запускалась.</span>
+          </div>
+          <div class="toolbar">
+            <button id="refreshEndpointListButton" class="secondary" type="button">Обновить список</button>
+            <button id="checkAllEndpointsButton" type="button">Проверить все endpoints</button>
+          </div>
+        </div>
+        <table class="table endpoint-table">
+          <thead>
+            <tr>
+              <th>Группа</th>
+              <th>Метод</th>
+              <th>Endpoint</th>
+              <th>Проверка</th>
+              <th>Статус</th>
+              <th></th>
+            </tr>
+          </thead>
+          <tbody id="endpointRows"></tbody>
+        </table>
+      </section>
+
       <div id="uploadsPanel" class="tab-panel hidden" data-tab-panel="uploads">
         <section id="uploadPanel">
           <div class="section-head">
@@ -1087,7 +1502,7 @@
     </div>
     <div class="modal-body">
       <section id="schedulesPanel">
-        <table class="table">
+        <table class="table schedule-table">
           <thead><tr><th>Источник</th><th>Расписание</th><th>Статус</th><th></th></tr></thead>
           <tbody id="schedulesBody"></tbody>
         </table>
@@ -1108,6 +1523,21 @@
     </div>
   </div>
 
+  <div id="endpointCheckModal" class="modal hidden" role="dialog" aria-modal="true" aria-labelledby="endpointCheckTitle">
+    <div class="modal-head">
+      <div>
+        <h2 id="endpointCheckTitle">Проверка API endpoints</h2>
+        <div id="endpointCheckSubtitle" class="muted">Запросы выполняются текущим JWT.</div>
+      </div>
+      <button class="ghost" data-close-modal type="button">Закрыть</button>
+    </div>
+    <div class="modal-body">
+      <div id="endpointCheckResults" class="endpoint-result-list"></div>
+    </div>
+  </div>
+
+  <script src="https://cdn.jsdelivr.net/npm/vue@3/dist/vue.global.prod.js"></script>
+  <script src="https://cdn.jsdelivr.net/npm/element-plus@2/dist/index.full.min.js"></script>
   <script>
     const tokenKey = "mostovik_dashboard_access";
     const refreshKey = "mostovik_dashboard_refresh";
@@ -1117,6 +1547,12 @@
     let activeMainTab = "analytics";
     let activeDrawerTab = "jobs";
     let requestLogPaused = false;
+    let sourceRecordsApp = null;
+    let latestRegistries = [];
+    let latestRegistryOrganizationTotal = 0;
+    let latestEndpointCatalog = [];
+    let latestEndpointResults = [];
+    let latestEndpointResultMap = new Map();
 
     const $ = (id) => document.getElementById(id);
 
@@ -1171,6 +1607,110 @@
       return `<span class="badge ${cls}">${escapeHtml(status || "-")}</span>`;
     }
 
+    function svgIcon(name) {
+      const icons = {
+        calendar: '<svg viewBox="0 0 24 24" aria-hidden="true"><path d="M8 2v4"></path><path d="M16 2v4"></path><path d="M3 10h18"></path><rect x="3" y="4" width="18" height="18" rx="2"></rect></svg>',
+        eye: '<svg viewBox="0 0 24 24" aria-hidden="true"><path d="M2 12s3.5-7 10-7 10 7 10 7-3.5 7-10 7-10-7-10-7z"></path><circle cx="12" cy="12" r="3"></circle></svg>',
+        pause: '<svg viewBox="0 0 24 24" aria-hidden="true"><path d="M8 5v14"></path><path d="M16 5v14"></path></svg>',
+        play: '<svg viewBox="0 0 24 24" aria-hidden="true"><path d="M8 5v14l11-7z"></path></svg>',
+        refresh: '<svg viewBox="0 0 24 24" aria-hidden="true"><path d="M21 12a9 9 0 0 1-15 6.7L3 16"></path><path d="M3 21v-5h5"></path><path d="M3 12a9 9 0 0 1 15-6.7L21 8"></path><path d="M21 3v5h-5"></path></svg>',
+        trash: '<svg viewBox="0 0 24 24" aria-hidden="true"><path d="M3 6h18"></path><path d="M8 6V4h8v2"></path><path d="M19 6l-1 14H6L5 6"></path><path d="M10 11v5"></path><path d="M14 11v5"></path></svg>',
+      };
+      return icons[name] || "";
+    }
+
+    function iconButton({ label, icon, className = "secondary", attrs = "" }) {
+      return `
+        <button class="icon-button ${className}" ${attrs} type="button" title="${escapeHtml(label)}" aria-label="${escapeHtml(label)}">
+          ${svgIcon(icon)}
+          <span class="sr-only">${escapeHtml(label)}</span>
+        </button>
+      `;
+    }
+
+    function statusLabel(status) {
+      const labels = {
+        enabled: "Включено",
+        disabled: "На паузе",
+        success: "Успешно",
+        failed: "Ошибка",
+        active: "Активно",
+      };
+      return labels[status] || status || "-";
+    }
+
+    function scheduleStatusBadge(enabled) {
+      const status = enabled ? "enabled" : "disabled";
+      const cls = enabled ? "ok" : "warn";
+      return `<span class="badge ${cls}">${escapeHtml(statusLabel(status))}</span>`;
+    }
+
+    function scheduleTypeLabel(schedule) {
+      if (schedule?.schedule_type === "crontab") return "Календарное расписание";
+      if (schedule?.schedule_type === "interval") return "Интервальное расписание";
+      return schedule?.schedule_type || "Расписание";
+    }
+
+    function pluralRu(value, one, few, many) {
+      const mod10 = Math.abs(value) % 10;
+      const mod100 = Math.abs(value) % 100;
+      if (mod10 === 1 && mod100 !== 11) return one;
+      if (mod10 >= 2 && mod10 <= 4 && (mod100 < 12 || mod100 > 14)) return few;
+      return many;
+    }
+
+    function intervalPeriodLabel(period) {
+      const map = {
+        microseconds: ["каждую микросекунду", "микросекунду", "микросекунды", "микросекунд"],
+        seconds: ["каждую секунду", "секунду", "секунды", "секунд"],
+        minutes: ["каждую минуту", "минуту", "минуты", "минут"],
+        hours: ["каждый час", "час", "часа", "часов"],
+        days: ["каждый день", "день", "дня", "дней"],
+      };
+      return map[period] || [period, period, period, period];
+    }
+
+    function humanizeSchedule(schedule) {
+      if (!schedule) return "Расписание не задано";
+      const payload = schedule.schedule || {};
+      if (schedule.schedule_type === "interval") {
+        const every = Number(payload.every || schedule.interval_every || 0);
+        const period = payload.period || schedule.interval_period || "";
+        const forms = intervalPeriodLabel(period);
+        if (!every) return "Интервал не задан";
+        return every === 1
+          ? forms[0].charAt(0).toUpperCase() + forms[0].slice(1)
+          : `Каждые ${formatNumber(every)} ${pluralRu(every, forms[1], forms[2], forms[3])}`;
+      }
+      if (schedule.schedule_type !== "crontab") return schedule.schedule_type || "Расписание не задано";
+
+      const minute = String(payload.minute ?? "*");
+      const hour = String(payload.hour ?? "*");
+      const dayOfWeek = String(payload.day_of_week ?? "*");
+      const dayOfMonth = String(payload.day_of_month ?? "*");
+      const monthOfYear = String(payload.month_of_year ?? "*");
+      const time = hour !== "*" && minute !== "*" ? `${hour.padStart(2, "0")}:${minute.padStart(2, "0")}` : "";
+      const weekdays = {
+        0: "Каждое воскресенье",
+        1: "Каждый понедельник",
+        2: "Каждый вторник",
+        3: "Каждую среду",
+        4: "Каждый четверг",
+        5: "Каждую пятницу",
+        6: "Каждую субботу",
+      };
+      if (dayOfMonth === "*" && monthOfYear === "*" && dayOfWeek !== "*" && weekdays[dayOfWeek]) {
+        return `${weekdays[dayOfWeek]}${time ? ` в ${time}` : ""} МСК`;
+      }
+      if (dayOfWeek === "*" && monthOfYear === "*" && dayOfMonth !== "*") {
+        return `Каждое ${dayOfMonth} число${time ? ` в ${time}` : ""} МСК`;
+      }
+      if (dayOfWeek === "*" && dayOfMonth === "*" && monthOfYear === "*" && time) {
+        return `Каждый день в ${time} МСК`;
+      }
+      return "Сложное cron-расписание";
+    }
+
     function parseMaybeJson(value) {
       if (value === null || value === undefined || value === "") return null;
       if (typeof value !== "string") return value;
@@ -1401,7 +1941,7 @@
 
     function closeModals() {
       $("modalBackdrop").classList.add("hidden");
-      ["schedulesModal", "sourceDetailModal"].forEach((id) => $(id).classList.add("hidden"));
+      ["schedulesModal", "sourceDetailModal", "endpointCheckModal"].forEach((id) => $(id).classList.add("hidden"));
     }
 
     function sourceRecordCount(source) {
@@ -1433,6 +1973,530 @@
       return found?.title || sourceValue;
     }
 
+    function registryDisplayName(name) {
+      return String(name || "")
+        .replace(/государственной корпорации/gi, "ГК")
+        .replace(/госкорпорации/gi, "ГК")
+        .replace(/\s+/g, " ")
+        .trim();
+    }
+
+    function endpointMethodChip(method) {
+      const normalized = String(method || "GET").toUpperCase();
+      return `<span class="method-chip ${escapeHtml(normalized.toLowerCase())}">${escapeHtml(normalized)}</span>`;
+    }
+
+    function endpointStatusBadge(statusCode, skipped = false) {
+      if (skipped) return `<span class="badge info">нет данных</span>`;
+      const code = Number(statusCode || 0);
+      const cls = code >= 200 && code < 300 ? "ok" : code >= 400 ? "fail" : "warn";
+      return `<span class="badge ${cls}">${code || "-"}</span>`;
+    }
+
+    function endpointCheckMethod(endpoint) {
+      if (endpoint.check_method) return endpoint.check_method;
+      return endpoint.method === "GET" ? "GET" : "OPTIONS";
+    }
+
+    function endpointCheckLabel(endpoint) {
+      if (endpoint.detail_from_list) return "GET по первой записи, если есть";
+      const method = endpointCheckMethod(endpoint);
+      return method === endpoint.method
+        ? `${method} real`
+        : `${method} без мутации`;
+    }
+
+    function endpointUrlWithPageSize(url) {
+      if (!url) return url;
+      const [path, query = ""] = url.split("?");
+      const params = new URLSearchParams(query);
+      if (!params.has("page_size") && !params.has("limit")) params.set("page_size", "1");
+      return `${path}?${params.toString()}`;
+    }
+
+    function endpointUrlWithParams(url, params) {
+      const [path, query = ""] = url.split("?");
+      const queryParams = new URLSearchParams(query);
+      Object.entries(params || {}).forEach(([key, value]) => {
+        if (value === undefined || value === null || value === "") return;
+        queryParams.set(key, value);
+      });
+      const queryString = queryParams.toString();
+      return queryString ? `${path}?${queryString}` : path;
+    }
+
+    function addEndpoint(catalog, endpoint) {
+      const key = `${endpoint.group}|${endpoint.method}|${endpoint.url}|${endpoint.title}`;
+      if (catalog.some((item) => item.key === key)) return;
+      catalog.push({
+        key,
+        check_method: endpoint.method === "GET" ? "GET" : "OPTIONS",
+        ...endpoint,
+      });
+    }
+
+    function addListAndDetailEndpoint(catalog, { group, title, listUrl, detailUrl, idField = "id", variants = [] }) {
+      const url = endpointUrlWithPageSize(listUrl);
+      addEndpoint(catalog, {
+        group,
+        title: `${title}: get_list`,
+        method: "GET",
+        url,
+        description: "Список с минимальной пагинацией",
+      });
+      variants.forEach((variant) => {
+        addEndpoint(catalog, {
+          group,
+          title: `${title}: ${variant.label}`,
+          method: "GET",
+          url: endpointUrlWithParams(url, variant.params),
+          description: variant.description || "Вариант list-запроса с query-параметрами",
+        });
+      });
+      if (detailUrl) {
+        addEndpoint(catalog, {
+          group,
+          title: `${title}: get`,
+          method: "GET",
+          url: detailUrl,
+          detail_from_list: url,
+          id_field: idField,
+          description: "Detail проверяется по первой записи из списка",
+        });
+      }
+    }
+
+    function buildEndpointCatalog() {
+      const catalog = [];
+      const sourceList = dashboardData?.sources || [];
+      const firstSource = sourceList[0]?.key || "industrial";
+      const parserResultVariants = [
+        { label: "page_size=5", params: { page_size: 5 } },
+        { label: "без payload", params: { include_payload: "false" } },
+        { label: "search", params: { search: "150" } },
+        { label: "ordering", params: { ordering: "-id" } },
+      ];
+
+      [
+        ["System", "Health", "GET", "/health/"],
+        ["System", "Live", "GET", "/health/live/"],
+        ["System", "Ready", "GET", "/health/ready/"],
+        ["Users", "Current user", "GET", "/api/v1/users/me/"],
+        ["Users", "Profile", "GET", "/api/v1/users/profile/"],
+        ["Users", "Full profile", "GET", "/api/v1/users/profile/full/"],
+        ["Users", "Login", "POST", "/api/v1/users/login/"],
+        ["Users", "Register", "POST", "/api/v1/users/register/"],
+        ["Users", "Refresh JWT", "POST", "/api/v1/users/token/refresh/"],
+        ["Users", "Verify JWT", "POST", "/api/v1/users/token/verify/"],
+        ["Parsers", "Dashboard data", "GET", "/api/v1/parsers/dashboard/"],
+        ["Parsers", "Source registry", "GET", "/api/v1/parsers/sources/"],
+        ["Parsers", "Generic records", "GET", "/api/v1/parsers/records/?limit=1"],
+        ["Parsers", "Load logs", "GET", "/api/v1/parsers/load-logs/?limit=1"],
+        ["Parsers", "Run parser", "POST", `/api/v1/parsers/run/${firstSource}/`],
+        ["Parsers", "Upload parser file", "POST", `/api/v1/parsers/upload/${firstSource}/`],
+        ["Parsers", "Schedules", "GET", "/api/v1/parsers/schedules/"],
+        ["Parsers", "Create schedule", "POST", "/api/v1/parsers/schedules/"],
+        ["Frontend", "Source cards", "GET", "/api/v1/sources/?page_size=1"],
+        ["Frontend", "Source statuses", "GET", "/api/v1/sources/statuses/"],
+        ["Registers", "Registries", "GET", "/api/v1/registers/registries/?page_size=1"],
+        ["Registers", "Organizations", "GET", "/api/v1/registers/organizations/?page_size=1"],
+        ["Registers", "Upload registry", "POST", "/api/v1/registers/upload/"],
+        ["Backups", "Export .bin", "POST", "/api/v1/backups/export/"],
+        ["Exchange", "Connections", "GET", "/api/v1/exchange/connections/"],
+        ["Exchange", "Create connection", "POST", "/api/v1/exchange/connections/"],
+        ["Exchange", "Test connection", "POST", "/api/v1/exchange/connections/test/"],
+        ["Exchange", "Tables", "GET", "/api/v1/exchange/tables/"],
+        ["Exchange", "Copy data", "POST", "/api/v1/exchange/copy/"],
+        ["Exchange", "Periodic tasks", "GET", "/api/v1/exchange/periodic-tasks/"],
+        ["Exchange", "Create periodic task", "POST", "/api/v1/exchange/periodic-tasks/"],
+        ["Jobs", "Jobs list", "GET", "/api/v1/jobs/?page_size=1"],
+        ["System", "Parser logs", "GET", "/api/v1/system/logs/?page_size=1"],
+        ["System", "Parser logs: status=success", "GET", "/api/v1/system/logs/?page_size=1&status=success"],
+        ["System", "Parser logs: source=industrial", "GET", "/api/v1/system/logs/?page_size=1&source=industrial"],
+        ["System", "Parser logs export", "GET", "/api/v1/system/logs/export/"],
+      ].forEach(([group, title, method, url]) => addEndpoint(catalog, { group, title, method, url }));
+
+      [
+        {
+          group: "Native data",
+          title: "Сертификаты Минпромторга",
+          listUrl: "/api/v1/minpromtorg/certificates/?page_size=1",
+          detailUrl: "/api/v1/minpromtorg/certificates/{id}/",
+          variants: [
+            { label: "search", params: { search: "150" } },
+            { label: "inn filter", params: { inn: "0000000000" } },
+          ],
+        },
+        {
+          group: "Native data",
+          title: "Производители Минпромторга",
+          listUrl: "/api/v1/minpromtorg/manufacturers/?page_size=1",
+          detailUrl: "/api/v1/minpromtorg/manufacturers/{id}/",
+          variants: [
+            { label: "search", params: { search: "150" } },
+            { label: "ogrn filter", params: { ogrn: "0000000000000" } },
+          ],
+        },
+        {
+          group: "Native data",
+          title: "Продукция Минпромторга",
+          listUrl: "/api/v1/minpromtorg/products/?page_size=1",
+          detailUrl: "/api/v1/minpromtorg/products/{id}/",
+          variants: [
+            { label: "search", params: { search: "продукт" } },
+            { label: "inn filter", params: { inn: "0000000000" } },
+          ],
+        },
+        {
+          group: "Native data",
+          title: "Проверки Генпрокуратуры",
+          listUrl: "/api/v1/proverki/?page_size=1",
+          detailUrl: "/api/v1/proverki/{id}/",
+          variants: [
+            { label: "search", params: { search: "150" } },
+            { label: "year filter", params: { data_year: "2026" } },
+          ],
+        },
+        {
+          group: "Native data",
+          title: "ЕИС Закупки",
+          listUrl: "/api/v1/zakupki/?page_size=1",
+          detailUrl: "/api/v1/zakupki/{id}/",
+          variants: [
+            { label: "44-ФЗ", params: { law_type: "44-FZ" } },
+            { label: "customer_inn", params: { customer_inn: "0000000000" } },
+          ],
+        },
+        {
+          group: "Native data",
+          title: "Финансовая отчетность ФНС",
+          listUrl: "/api/v1/fns/reports/?page_size=1",
+          detailUrl: "/api/v1/fns/reports/{id}/",
+          variants: [
+            { label: "source", params: { source: "fns_financial" } },
+            { label: "status", params: { status: "success" } },
+          ],
+        },
+      ].forEach((definition) => {
+        addListAndDetailEndpoint(catalog, definition);
+      });
+
+      [
+        ["Registers", "Registries: search", "/api/v1/registers/registries/?search=рос&page_size=1"],
+        ["Registers", "Organizations: search", "/api/v1/registers/organizations/?search=организация&page_size=1"],
+        ["Registers", "Organizations: mn_inn", "/api/v1/registers/organizations/?mn_inn=0&page_size=1"],
+        ["Frontend", "Source cards: search", "/api/v1/sources/?search=фнс&page_size=1"],
+      ].forEach(([group, title, url]) => addEndpoint(catalog, { group, title, method: "GET", url }));
+
+      sourceList.forEach((source) => {
+        if (!source.result_list_url) return;
+        addListAndDetailEndpoint(catalog, {
+          group: "Parser results",
+          title: source.title,
+          listUrl: source.result_list_url,
+          detailUrl: source.result_detail_url,
+          variants: parserResultVariants,
+        });
+        if (source.upload_url) {
+          addEndpoint(catalog, {
+            group: "Manual uploads",
+            title: `${source.title}: upload`,
+            method: "POST",
+            url: source.upload_url,
+            description: "Проверяется OPTIONS, файл не отправляется",
+          });
+        }
+      });
+
+      return catalog;
+    }
+
+    function extractResultList(payload) {
+      if (Array.isArray(payload)) return payload;
+      if (Array.isArray(payload?.data)) return payload.data;
+      if (Array.isArray(payload?.results)) return payload.results;
+      if (Array.isArray(payload?.data?.results)) return payload.data.results;
+      return [];
+    }
+
+    function endpointResponseSummary(payload) {
+      const pretty = prettyPayload(payload);
+      return pretty ? pretty.slice(0, 1200) : "-";
+    }
+
+    async function endpointProbeFetch(url, options = {}) {
+      const method = options.method || "GET";
+      const body = options.body ? JSON.stringify(options.body) : undefined;
+      const started = performance.now();
+      try {
+        const response = await fetch(url, {
+          method,
+          headers: {
+            Accept: "application/json",
+            ...(body ? { "Content-Type": "application/json" } : {}),
+            ...(accessToken ? { Authorization: `Bearer ${accessToken}` } : {}),
+          },
+          body,
+        });
+        const text = await response.text();
+        logRequest(method, url, options.body || null, `${response.status} ${Math.round(performance.now() - started)}ms`, text);
+        let payload = {};
+        try { payload = text ? JSON.parse(text) : {}; } catch (_) { payload = { raw: text }; }
+        return {
+          ok: response.ok,
+          status_code: response.status,
+          elapsed_ms: Math.round(performance.now() - started),
+          request: { method, url, body: options.body || null },
+          response: payload,
+        };
+      } catch (error) {
+        return {
+          ok: false,
+          status_code: 0,
+          elapsed_ms: Math.round(performance.now() - started),
+          request: { method, url, body: options.body || null },
+          response: { error: errorMessage(error) },
+        };
+      }
+    }
+
+    function firstRecordId(payload, idField = "id") {
+      const first = extractResultList(payload)[0];
+      return first?.[idField] || first?.id || first?.uuid || first?.task_id || "";
+    }
+
+    async function probeEndpoint(endpoint) {
+      if (endpoint.detail_from_list) {
+        const listProbe = await endpointProbeFetch(endpoint.detail_from_list, { method: "GET" });
+        const id = firstRecordId(listProbe.response, endpoint.id_field || "id");
+        if (!id) {
+          return {
+            ...listProbe,
+            skipped: true,
+            ok: true,
+            status_code: 204,
+            request: { method: "GET", url: endpoint.url, body: null },
+            response: { message: "В списке нет записи для проверки detail endpoint. Это не ошибка API." },
+          };
+        }
+        return endpointProbeFetch(endpoint.url.replace("{id}", encodeURIComponent(id)), { method: "GET" });
+      }
+      return endpointProbeFetch(endpoint.url, { method: endpointCheckMethod(endpoint) });
+    }
+
+    function renderEndpointRows(resultsByIndex = latestEndpointResultMap) {
+      latestEndpointCatalog = buildEndpointCatalog();
+      $("endpointCount").textContent = `${latestEndpointCatalog.length} endpoints`;
+      $("endpointRows").innerHTML = latestEndpointCatalog.map((endpoint, index) => {
+        const result = resultsByIndex.get(index);
+        return `
+          <tr data-endpoint-index="${index}">
+            <td>${escapeHtml(endpoint.group)}</td>
+            <td>
+              ${endpointMethodChip(endpoint.method)}
+              ${endpoint.method !== endpointCheckMethod(endpoint) ? `<br><span class="muted">check: ${escapeHtml(endpointCheckMethod(endpoint))}</span>` : ""}
+            </td>
+            <td>
+              <div class="endpoint-title">
+                <strong>${escapeHtml(endpoint.title)}</strong>
+                <span class="endpoint-url" title="${escapeHtml(endpoint.url)}">${escapeHtml(endpoint.url)}</span>
+              </div>
+            </td>
+            <td>${escapeHtml(endpointCheckLabel(endpoint))}</td>
+            <td>${result ? endpointStatusBadge(result.status_code, result.skipped) : `<span class="muted">-</span>`}</td>
+            <td>
+              <div class="endpoint-actions">
+                ${iconButton({
+                  label: "Проверить endpoint",
+                  icon: "refresh",
+                  attrs: `data-endpoint-run="${index}"`,
+                })}
+                ${iconButton({
+                  label: "Показать request/response",
+                  icon: "eye",
+                  attrs: `data-endpoint-detail="${index}"`,
+                })}
+              </div>
+            </td>
+          </tr>
+        `;
+      }).join("");
+    }
+
+    function endpointResultStats(results) {
+      return {
+        success: results.filter((result) => result.ok && !result.skipped).length,
+        failed: results.filter((result) => !result.ok && !result.skipped).length,
+        skipped: results.filter((result) => result.skipped).length,
+      };
+    }
+
+    function updateEndpointCheckSummary(running = false) {
+      const stats = endpointResultStats(latestEndpointResults);
+      if (running) {
+        $("endpointCheckSummary").textContent = `Проверено ${latestEndpointResults.length} из ${latestEndpointCatalog.length}`;
+        return;
+      }
+      $("endpointCheckSummary").textContent = latestEndpointResults.length
+        ? `Успешно: ${stats.success}, ошибок: ${stats.failed}, без данных: ${stats.skipped}`
+        : "Проверка еще не запускалась.";
+    }
+
+    function renderEndpointCheckResults(results, running = false) {
+      const stats = endpointResultStats(results);
+      $("endpointCheckTitle").textContent = results.length === 1
+        ? `Endpoint: ${results[0].endpoint.title}`
+        : "Проверка API endpoints";
+      $("endpointCheckSubtitle").textContent = running
+        ? `Выполнено ${results.length} из ${latestEndpointCatalog.length}`
+        : `Успешно: ${stats.success}, ошибок: ${stats.failed}, без данных: ${stats.skipped}`;
+      $("endpointCheckResults").innerHTML = results.map((result) => `
+        <article class="endpoint-result">
+          <header>
+            <div>
+              <strong>${escapeHtml(result.endpoint.title)}</strong>
+              <div class="endpoint-url">${escapeHtml(result.request.url)}</div>
+            </div>
+            <div class="toolbar">
+              ${endpointMethodChip(result.request.method)}
+              ${endpointStatusBadge(result.status_code, result.skipped)}
+            </div>
+          </header>
+          <details>
+            <summary>request</summary>
+            <pre>${escapeHtml(JSON.stringify(result.request, null, 2))}</pre>
+          </details>
+          <details ${result.ok ? "" : "open"}>
+            <summary>response</summary>
+            <pre>${escapeHtml(endpointResponseSummary(result.response))}</pre>
+          </details>
+        </article>
+      `).join("") || `<div class="empty-state">Проверка еще не запускалась.</div>`;
+    }
+
+    async function ensureEndpointCheckAuth() {
+      if (!accessToken) return false;
+      const probe = await endpointProbeFetch("/api/v1/users/me/", { method: "GET" });
+      if (probe.ok) return true;
+      if (probe.status_code === 401) {
+        await refreshJwt();
+        if (!accessToken) return false;
+        const retry = await endpointProbeFetch("/api/v1/users/me/", { method: "GET" });
+        return retry.ok;
+      }
+      return probe.status_code !== 403;
+    }
+
+    async function runEndpointChecks() {
+      latestEndpointResults = [];
+      latestEndpointResultMap = new Map();
+      renderEndpointRows();
+      updateEndpointCheckSummary(true);
+      const button = $("checkAllEndpointsButton");
+      button.disabled = true;
+      button.textContent = "Проверка...";
+      try {
+        const isAuthenticatedForCheck = await ensureEndpointCheckAuth();
+        if (!isAuthenticatedForCheck) {
+          $("endpointCheckSummary").textContent = "JWT недействителен или отсутствует. Обновите JWT или войдите заново.";
+          return;
+        }
+        for (let index = 0; index < latestEndpointCatalog.length; index += 1) {
+          await runSingleEndpointCheck(index, { render: false });
+          renderEndpointRows();
+          updateEndpointCheckSummary(true);
+        }
+        updateEndpointCheckSummary(false);
+      } finally {
+        button.disabled = false;
+        button.textContent = "Проверить все endpoints";
+      }
+    }
+
+    async function runSingleEndpointCheck(index, { render = true } = {}) {
+      const endpoint = latestEndpointCatalog[index];
+      if (!endpoint) return null;
+      const result = { index, endpoint, ...(await probeEndpoint(endpoint)) };
+      latestEndpointResultMap.set(index, result);
+      latestEndpointResults = Array.from(latestEndpointResultMap.values()).sort((a, b) => a.index - b.index);
+      if (render) {
+        renderEndpointRows();
+        updateEndpointCheckSummary(false);
+      }
+      return result;
+    }
+
+    async function showEndpointDetail(index) {
+      const endpoint = latestEndpointCatalog[index];
+      if (!endpoint) return;
+      $("endpointCheckTitle").textContent = `Endpoint: ${endpoint.title}`;
+      $("endpointCheckSubtitle").textContent = "Загружаю request/response...";
+      $("endpointCheckResults").innerHTML = `<div class="empty-state">Проверяем конкретный endpoint.</div>`;
+      openModal("endpointCheckModal");
+      let result = latestEndpointResultMap.get(index);
+      if (!result) {
+        result = await runSingleEndpointCheck(index);
+      }
+      renderEndpointCheckResults([result], false);
+    }
+
+    function renderRegistryCompleteness() {
+      const container = $("registryCompletenessChart");
+      if (!container) return;
+      const registries = latestRegistries || [];
+      if (!registries.length) {
+        container.innerHTML = `<div class="empty-state">Реестры организаций пока не загружены.</div>`;
+        return;
+      }
+
+      const totalOrganizations = Number(latestRegistryOrganizationTotal || 0);
+      const activeMemberships = registries.reduce(
+        (sum, registry) => sum + Number(registry.active_organizations || 0),
+        0,
+      );
+      const registriesWithData = registries.filter((registry) => Number(registry.active_organizations || 0) > 0).length;
+      const filledPercent = registries.length
+        ? Math.round(registriesWithData / registries.length * 100)
+        : 0;
+      const maxRegistryCount = Math.max(...registries.map((registry) => Number(registry.active_organizations || 0)), 1);
+      const rows = [...registries]
+        .sort((a, b) => Number(b.active_organizations || 0) - Number(a.active_organizations || 0))
+        .map((registry) => {
+          const active = Number(registry.active_organizations || 0);
+          const coverage = totalOrganizations ? Math.round(active / totalOrganizations * 100) : 0;
+          const width = Math.max(active ? 4 : 0, Math.round(active / maxRegistryCount * 100));
+          const displayName = registryDisplayName(registry.name);
+          return `
+            <div class="registry-bar-row">
+              <div class="registry-bar-title">
+                <strong title="${escapeHtml(registry.name)}">${escapeHtml(displayName)}</strong>
+                <span class="muted">${formatNumber(registry.uploads_count || 0)} загрузок</span>
+              </div>
+              <div class="bar-track" title="${formatNumber(active)} организаций">
+                <span style="width:${width}%"></span>
+              </div>
+              <div class="registry-bar-value">
+                <strong>${formatNumber(active)}</strong>
+                <span class="muted">${coverage}%</span>
+              </div>
+            </div>
+          `;
+        })
+        .join("");
+
+      container.innerHTML = `
+        <div class="registry-score-card">
+          <span class="muted">Уникальных организаций</span>
+          <strong>${formatNumber(totalOrganizations)}</strong>
+          <div class="legend">
+            <span class="badge info">${formatNumber(activeMemberships)} активных участий</span>
+            <span class="badge ${filledPercent >= 80 ? "ok" : filledPercent ? "warn" : "fail"}">${filledPercent}% реестров с данными</span>
+          </div>
+        </div>
+        <div class="registry-bars">${rows}</div>
+      `;
+    }
+
     function renderAnalytics() {
       const sources = dashboardData?.sources || [];
       const loadMap = latestLoadsBySource();
@@ -1493,6 +2557,7 @@
       $("modeBreakdown").innerHTML = Object.entries(modeCounts).map(([mode, count]) => `
         <div class="mode-pill"><span class="muted">${escapeHtml(mode)}</span><strong>${formatNumber(count)}</strong></div>
       `).join("");
+      renderRegistryCompleteness();
     }
 
     function renderSourceCards(items) {
@@ -1687,13 +2752,23 @@
     }
 
     async function refreshRegisters() {
-      const response = await apiFetch("/api/v1/registers/registries/?page_size=100");
+      const [response, organizationsResponse] = await Promise.all([
+        apiFetch("/api/v1/registers/registries/?page_size=100"),
+        apiFetch("/api/v1/registers/organizations/?page_size=1"),
+      ]);
       const registries = listPayload(response);
+      const organizations = listPayload(organizationsResponse);
+      latestRegistries = registries;
+      latestRegistryOrganizationTotal = listTotal(organizationsResponse, organizations);
       renderRegistryUploadPanel(registries);
       renderBackupPanel(registries);
+      renderAnalytics();
     }
 
     function renderRegistersUnavailable(error) {
+      latestRegistries = [];
+      latestRegistryOrganizationTotal = 0;
+      renderAnalytics();
       $("registryCount").textContent = "недоступно";
       $("registrySelect").innerHTML = "";
       $("backupRegistrySelect").innerHTML = "";
@@ -1781,6 +2856,7 @@
       renderAnalytics();
       renderSourceCards(sources);
       renderUploadSources(groups.uploads || [], "uploadSources");
+      renderEndpointRows();
 
       $("jobsBody").innerHTML = (dashboardData.jobs || []).map((job) => {
         const canRevoke = ["pending", "started", "retry"].includes(job.status);
@@ -1796,12 +2872,36 @@
 
       $("schedulesBody").innerHTML = (dashboardData.schedules || []).map((schedule) => `
         <tr>
-          <td>${escapeHtml(schedule.title)}<br><span class="muted">${escapeHtml(schedule.name)}</span></td>
-          <td>${escapeHtml(schedule.schedule_type)}:<br><span class="muted">${escapeHtml(JSON.stringify(schedule.schedule))}</span></td>
-          <td>${schedule.enabled ? statusBadge("enabled") : statusBadge("disabled")}</td>
           <td>
-            <button class="secondary" data-toggle="${schedule.id}" data-enabled="${!schedule.enabled}" type="button">${schedule.enabled ? "Пауза" : "Включить"}</button>
-            <button class="danger" data-delete="${schedule.id}" type="button">Удалить</button>
+            <div class="schedule-source">
+              <strong>${escapeHtml(schedule.title)}</strong>
+              <span class="muted mono">${escapeHtml(schedule.name)}</span>
+            </div>
+          </td>
+          <td>
+            <div class="schedule-plan">
+              <span class="schedule-plan-icon">${svgIcon("calendar")}</span>
+              <span class="schedule-plan-text">
+                <strong>${escapeHtml(humanizeSchedule(schedule))}</strong>
+                <span class="muted">${escapeHtml(scheduleTypeLabel(schedule))}</span>
+              </span>
+            </div>
+          </td>
+          <td>${scheduleStatusBadge(schedule.enabled)}</td>
+          <td>
+            <div class="schedule-actions">
+              ${iconButton({
+                label: schedule.enabled ? "Поставить на паузу" : "Включить",
+                icon: schedule.enabled ? "pause" : "play",
+                attrs: `data-toggle="${schedule.id}" data-enabled="${!schedule.enabled}"`,
+              })}
+              ${iconButton({
+                label: "Удалить расписание",
+                icon: "trash",
+                className: "danger",
+                attrs: `data-delete="${schedule.id}"`,
+              })}
+            </div>
           </td>
         </tr>
       `).join("") || `<tr><td colspan="4"><div class="empty-state">Активных расписаний пока нет.</div></td></tr>`;
@@ -1817,80 +2917,255 @@
     }
 
     function recordLabel(record) {
-      return record.organisation_name || record.title || record.external_id || `Запись ${record.id}`;
+      return record.organisation_name
+        || record.full_legal_name
+        || record.full_organisation_name
+        || record.customer_name
+        || record.purchase_name
+        || record.product_name
+        || record.title
+        || record.file_name
+        || record.external_id
+        || record.certificate_number
+        || record.registration_number
+        || record.registry_number
+        || `Запись ${record.id}`;
+    }
+
+    function recordExternalId(record) {
+      return record.external_id
+        || record.certificate_number
+        || record.registration_number
+        || record.registry_number
+        || record.purchase_number
+        || record.inn
+        || "";
+    }
+
+    function recordInn(record) {
+      return record.inn || record.customer_inn || "-";
+    }
+
+    function recordOgrn(record) {
+      return record.ogrn || record.customer_ogrn || "";
+    }
+
+    function recordDate(record) {
+      return record.record_date
+        || record.issue_date
+        || record.publish_date
+        || record.start_date
+        || record.created_at
+        || "-";
+    }
+
+    function recordStatus(record) {
+      return record.status || "-";
+    }
+
+    function recordAmount(record) {
+      return record.amount || record.max_price_amount || record.max_price || "";
+    }
+
+    function recordPayload(record) {
+      return record.payload && Object.keys(record.payload).length ? record.payload : record;
+    }
+
+    function listTotal(response, records) {
+      const candidates = [
+        response?.count,
+        response?.total,
+        response?.meta?.pagination?.count,
+        response?.meta?.total,
+        response?.data?.count,
+        response?.data?.total,
+        response?.data?.meta?.pagination?.count,
+        response?.data?.meta?.total,
+      ];
+      const value = candidates.find((item) => Number.isFinite(Number(item)));
+      return value === undefined ? records.length : Number(value);
+    }
+
+    function createSourceRecordsApp() {
+      const mountNode = $("sourceRecordsApp");
+      if (!mountNode) return null;
+      if (!window.Vue || !window.ElementPlus) {
+        mountNode.removeAttribute("v-cloak");
+        mountNode.innerHTML = `<div class="empty-state">Vue 3 или Element Plus не загрузились с CDN. Проверьте доступность CDN и обновите страницу.</div>`;
+        return null;
+      }
+      const app = window.Vue.createApp({
+        data() {
+          return {
+            mode: "list",
+            source: null,
+            itemId: "",
+            records: [],
+            detailRecord: null,
+            loading: false,
+            error: "",
+            page: 1,
+            pageSize: 100,
+            pageSizes: [25, 50, 100, 200],
+            total: 0,
+            tableHeight: 560,
+            lastRoute: { sourceKey: "", itemId: "" },
+          };
+        },
+        computed: {
+          footerText() {
+            if (this.loading && this.records.length) return "Обновляю данные без сброса таблицы.";
+            if (!this.records.length) return "Нет строк для отображения.";
+            const start = (this.page - 1) * this.pageSize + 1;
+            const end = start + this.records.length - 1;
+            return `${start}-${end} из ${formatNumber(this.total || this.records.length)}`;
+          },
+          detailFields() {
+            const record = this.detailRecord || {};
+            return [
+              ["ID", record.id],
+              ["Источник", record.source],
+              ["External ID", record.external_id],
+              ["Организация", recordLabel(record)],
+              ["Заголовок", record.title || record.product_name || record.purchase_name],
+              ["ИНН", recordInn(record)],
+              ["ОГРН", recordOgrn(record)],
+              ["Дата", recordDate(record)],
+              ["Статус", recordStatus(record)],
+              ["Сумма", recordAmount(record)],
+              ["URL", record.url || record.href || record.certificate_file_url],
+              ["Batch", record.load_batch],
+            ].map(([label, value]) => ({ label, value: value || "-" }));
+          },
+          detailPayload() {
+            return JSON.stringify(recordPayload(this.detailRecord || {}), null, 2);
+          },
+        },
+        methods: {
+          recordRowKey(row) {
+            return row.id;
+          },
+          recordLabel(record) {
+            return recordLabel(record);
+          },
+          recordExternalId(record) {
+            return recordExternalId(record);
+          },
+          recordInn(record) {
+            return recordInn(record);
+          },
+          recordOgrn(record) {
+            return recordOgrn(record);
+          },
+          recordDate(record) {
+            return recordDate(record);
+          },
+          recordStatus(record) {
+            return recordStatus(record);
+          },
+          recordAmount(record) {
+            return recordAmount(record);
+          },
+          isCurrentRoute(sourceKey, itemId = "") {
+            return this.lastRoute.sourceKey === sourceKey
+              && String(this.lastRoute.itemId || "") === String(itemId || "");
+          },
+          syncHeader(source, itemId = "") {
+            $("routeTitle").textContent = source.title;
+            $("routeSubtitle").textContent = itemId
+              ? `${source.agency} · запись #${itemId}`
+              : `${source.agency} · ${source.source} · ${source.parser_strategy}`;
+          },
+          showRouteError(title, subtitle, message) {
+            $("routeTitle").textContent = title;
+            $("routeSubtitle").textContent = subtitle || "";
+            this.mode = "list";
+            this.records = [];
+            this.detailRecord = null;
+            this.total = 0;
+            this.error = message;
+            this.loading = false;
+          },
+          async loadList(source) {
+            if (!source) return;
+            this.mode = "list";
+            this.source = source;
+            this.itemId = "";
+            this.lastRoute = { sourceKey: source.key, itemId: "" };
+            this.syncHeader(source);
+            this.error = "";
+            this.loading = true;
+            try {
+              const listUrl = source.result_list_url || `/api/v1/parsers/records/`;
+              const query = {
+                page: this.page,
+                page_size: this.pageSize,
+              };
+              if (!source.result_list_url) {
+                query.source = source.source;
+                query.limit = this.pageSize;
+              }
+              const response = await apiFetch(withQuery(listUrl, query));
+              const records = listPayload(response);
+              this.records = records;
+              this.total = listTotal(response, records);
+            } catch (error) {
+              this.error = errorMessage(error);
+              if (!this.records.length) this.total = 0;
+            } finally {
+              this.loading = false;
+            }
+          },
+          async loadDetail(source, itemId) {
+            this.mode = "detail";
+            this.source = source;
+            this.itemId = itemId;
+            this.lastRoute = { sourceKey: source.key, itemId };
+            this.syncHeader(source, itemId);
+            this.error = "";
+            this.loading = true;
+            try {
+              const detailUrl = source.result_detail_url
+                ? source.result_detail_url.replace("{id}", encodeURIComponent(itemId))
+                : `/api/v1/parsers/records/`;
+              const response = await apiFetch(source.result_detail_url
+                ? detailUrl
+                : withQuery(detailUrl, { source: source.source, id: itemId, limit: 1 }));
+              const record = Array.isArray(response.data) ? (response.data || [])[0] : response.data;
+              this.detailRecord = record || null;
+              if (!record) this.error = "Запись не найдена.";
+            } catch (error) {
+              this.error = errorMessage(error);
+              this.detailRecord = null;
+            } finally {
+              this.loading = false;
+            }
+          },
+          openRecord(row) {
+            if (!this.source || !row?.id) return;
+            navigateDashboard(`/dashboard/${encodeURIComponent(this.source.key)}/${row.id}`);
+          },
+          handlePageChange(page) {
+            this.page = page;
+            this.loadList(this.source);
+          },
+          handlePageSizeChange(size) {
+            this.pageSize = size;
+            this.page = 1;
+            this.loadList(this.source);
+          },
+        },
+      });
+      app.use(window.ElementPlus);
+      return app.mount("#sourceRecordsApp");
     }
 
     async function renderSourceRecords(source) {
-      $("sourceTableView").classList.remove("hidden");
-      $("itemDetailView").classList.add("hidden");
-      $("routeTitle").textContent = source.title;
-      $("routeSubtitle").textContent = `${source.agency} · ${source.source} · ${source.parser_strategy}`;
-      $("recordsEmpty").classList.add("hidden");
-      $("recordsBody").innerHTML = `<tr><td colspan="5"><div class="empty-state">Загрузка данных...</div></td></tr>`;
-
-      const listUrl = source.result_list_url || `/api/v1/parsers/records/`;
-      const query = {
-        page_size: 100,
-        limit: 100,
-      };
-      if (!source.result_list_url) query.source = source.source;
-      const response = await apiFetch(withQuery(listUrl, query));
-      const records = listPayload(response);
-      if (!records.length) {
-        $("recordsBody").innerHTML = "";
-        $("recordsEmpty").textContent = "По этому источнику записей пока нет. Запустите парсер или дождитесь завершения Celery-задачи.";
-        $("recordsEmpty").classList.remove("hidden");
-        return;
-      }
-
-      $("recordsBody").innerHTML = records.map((record) => `
-        <tr data-record-id="${record.id}">
-          <td>${record.id}</td>
-          <td>${escapeHtml(recordLabel(record))}<br><span class="muted">${escapeHtml(record.external_id || "")}</span></td>
-          <td>${escapeHtml(record.inn || "-")}<br><span class="muted">${escapeHtml(record.ogrn || "")}</span></td>
-          <td>${escapeHtml(record.record_date || "-")}</td>
-          <td>${escapeHtml(record.status || "-")}${record.amount ? `<br><span class="muted">${escapeHtml(record.amount)}</span>` : ""}</td>
-        </tr>
-      `).join("");
+      await sourceRecordsApp?.loadList(source);
     }
 
     async function renderItemDetail(source, itemId) {
-      $("sourceTableView").classList.add("hidden");
-      $("itemDetailView").classList.remove("hidden");
-      $("routeTitle").textContent = source.title;
-      $("routeSubtitle").textContent = `${source.agency} · запись #${itemId}`;
-
-      const detailUrl = source.result_detail_url
-        ? source.result_detail_url.replace("{id}", encodeURIComponent(itemId))
-        : `/api/v1/parsers/records/`;
-      const response = await apiFetch(source.result_detail_url
-        ? detailUrl
-        : withQuery(detailUrl, { source: source.source, id: itemId, limit: 1 }));
-      const record = Array.isArray(response.data) ? (response.data || [])[0] : response.data;
-      if (!record) {
-        $("itemFields").innerHTML = "";
-        $("itemPayload").textContent = "Запись не найдена";
-        return;
-      }
-
-      const fields = [
-        ["ID", record.id],
-        ["Источник", record.source],
-        ["External ID", record.external_id],
-        ["Организация", record.organisation_name],
-        ["Заголовок", record.title],
-        ["ИНН", record.inn],
-        ["ОГРН", record.ogrn],
-        ["Дата", record.record_date],
-        ["Статус", record.status],
-        ["Сумма", record.amount],
-        ["URL", record.url],
-        ["Batch", record.load_batch],
-      ];
-      $("itemFields").innerHTML = fields.map(([label, value]) => `
-        <div class="detail-field"><span>${escapeHtml(label)}</span>${value ? escapeHtml(value) : "-"}</div>
-      `).join("");
-      $("itemPayload").textContent = JSON.stringify(record.payload || {}, null, 2);
+      await sourceRecordsApp?.loadDetail(source, itemId);
     }
 
     async function renderCurrentRoute() {
@@ -1899,11 +3174,11 @@
 
       const source = sourceByKey(route.sourceKey);
       if (!source) {
-        $("routeTitle").textContent = "Источник не найден";
-        $("routeSubtitle").textContent = route.sourceKey;
-        $("recordsBody").innerHTML = "";
-        $("recordsEmpty").textContent = "Такого источника нет в каталоге парсеров.";
-        $("recordsEmpty").classList.remove("hidden");
+        sourceRecordsApp?.showRouteError(
+          "Источник не найден",
+          route.sourceKey,
+          "Такого источника нет в каталоге парсеров.",
+        );
         return;
       }
 
@@ -1914,8 +3189,7 @@
           await renderSourceRecords(source);
         }
       } catch (error) {
-        $("recordsEmpty").textContent = JSON.stringify(error);
-        $("recordsEmpty").classList.remove("hidden");
+        sourceRecordsApp?.showRouteError(source.title, source.source, errorMessage(error));
       }
     }
 
@@ -1928,7 +3202,10 @@
         renderDashboard(data);
         await refreshRegisters().catch(renderRegistersUnavailable);
         await refreshExchange();
-        await renderCurrentRoute();
+        const route = parseRoute();
+        if (route.sourceKey && !sourceRecordsApp?.isCurrentRoute(route.sourceKey, route.itemId)) {
+          await renderCurrentRoute();
+        }
         setLoginMessage("");
       } catch (error) {
         if (isAuthError(error)) {
@@ -2103,6 +3380,13 @@
 
     document.body.addEventListener("click", async (event) => {
       const target = event.target;
+      const scheduleToggle = target.closest?.("[data-toggle]");
+      const scheduleDelete = target.closest?.("[data-delete]");
+      const jobRevoke = target.closest?.("[data-revoke]");
+      const exchangeToggle = target.closest?.("[data-exchange-toggle]");
+      const exchangeDelete = target.closest?.("[data-exchange-delete]");
+      const endpointRun = target.closest?.("[data-endpoint-run]");
+      const endpointDetail = target.closest?.("[data-endpoint-detail]");
       if (target.dataset.mainTab) showMainTab(target.dataset.mainTab);
       if (target.id === "requestDrawerButton") openLeftDrawer();
       if (target.id === "operationsDrawerButton") openRightDrawer("jobs");
@@ -2124,6 +3408,22 @@
       }
       if (target.id === "refreshTokenButton") await refreshJwt();
       if (target.id === "refreshButton" || target.id === "drawerRefreshButton") await refreshDashboard();
+      if (target.id === "refreshEndpointListButton") {
+        latestEndpointResults = [];
+        latestEndpointResultMap = new Map();
+        renderEndpointRows();
+        updateEndpointCheckSummary(false);
+      }
+      if (target.id === "checkAllEndpointsButton") await runEndpointChecks();
+      if (endpointRun) {
+        endpointRun.disabled = true;
+        try {
+          await runSingleEndpointCheck(Number(endpointRun.dataset.endpointRun));
+        } finally {
+          endpointRun.disabled = false;
+        }
+      }
+      if (endpointDetail) await showEndpointDetail(Number(endpointDetail.dataset.endpointDetail));
       if (target.dataset.authMode) {
         const mode = target.dataset.authMode;
         document.querySelectorAll("[data-auth-mode]").forEach((button) => {
@@ -2201,41 +3501,41 @@
         const route = parseRoute();
         navigateDashboard(`/dashboard/${encodeURIComponent(route.sourceKey)}/${recordRow.dataset.recordId}`);
       }
-      if (target.dataset.revoke) {
-        await apiFetch(`/api/v1/jobs/${target.dataset.revoke}/control/`, {
+      if (jobRevoke) {
+        await apiFetch(`/api/v1/jobs/${jobRevoke.dataset.revoke}/control/`, {
           method: "POST",
           body: JSON.stringify({ action: "revoke" }),
         });
         await refreshDashboard();
       }
-      if (target.dataset.toggle) {
-        await apiFetch(`/api/v1/parsers/schedules/${target.dataset.toggle}/`, {
+      if (scheduleToggle) {
+        await apiFetch(`/api/v1/parsers/schedules/${scheduleToggle.dataset.toggle}/`, {
           method: "PATCH",
-          body: JSON.stringify({ enabled: target.dataset.enabled === "true" }),
+          body: JSON.stringify({ enabled: scheduleToggle.dataset.enabled === "true" }),
         });
         await refreshDashboard();
       }
-      if (target.dataset.delete) {
-        await apiFetch(`/api/v1/parsers/schedules/${target.dataset.delete}/`, { method: "DELETE" });
+      if (scheduleDelete) {
+        await apiFetch(`/api/v1/parsers/schedules/${scheduleDelete.dataset.delete}/`, { method: "DELETE" });
         await refreshDashboard();
       }
-      if (target.dataset.exchangeToggle) {
+      if (exchangeToggle) {
         if (!userCanManageExchange()) {
           renderExchangeRestricted();
           return;
         }
-        await apiFetch(`/api/v1/exchange/periodic-tasks/${target.dataset.exchangeToggle}/`, {
+        await apiFetch(`/api/v1/exchange/periodic-tasks/${exchangeToggle.dataset.exchangeToggle}/`, {
           method: "PATCH",
-          body: JSON.stringify({ enabled: target.dataset.enabled === "true" }),
+          body: JSON.stringify({ enabled: exchangeToggle.dataset.enabled === "true" }),
         });
         await refreshExchange();
       }
-      if (target.dataset.exchangeDelete) {
+      if (exchangeDelete) {
         if (!userCanManageExchange()) {
           renderExchangeRestricted();
           return;
         }
-        await apiFetch(`/api/v1/exchange/periodic-tasks/${target.dataset.exchangeDelete}/`, { method: "DELETE" });
+        await apiFetch(`/api/v1/exchange/periodic-tasks/${exchangeDelete.dataset.exchangeDelete}/`, { method: "DELETE" });
         await refreshExchange();
       }
     });
@@ -2245,6 +3545,7 @@
       renderCurrentRoute();
     });
 
+    sourceRecordsApp = createSourceRecordsApp();
     setAuthenticated(Boolean(accessToken));
     refreshDashboard();
     setInterval(refreshDashboard, 10000);
diff --git a/tests/apps/parsers/test_dashboard_page.py b/tests/apps/parsers/test_dashboard_page.py
index c3c14fc..a5bf153 100644
--- a/tests/apps/parsers/test_dashboard_page.py
+++ b/tests/apps/parsers/test_dashboard_page.py
@@ -29,3 +29,50 @@ class ParserDashboardPageTest(TestCase):
         content = response.content.decode()
         self.assertIn("function sourceGroups()", content)
         self.assertIn("dashboardData?.file_sources", content)
+
+    def test_dashboard_uses_vue_component_table_for_source_results(self):
+        response = self.client.get("/dashboard")
+
+        self.assertEqual(response.status_code, 200)
+        content = response.content.decode()
+        self.assertIn("https://cdn.jsdelivr.net/npm/vue@3/", content)
+        self.assertIn("https://cdn.jsdelivr.net/npm/element-plus@2/", content)
+        self.assertIn('id="sourceRecordsApp"', content)
+        self.assertIn("<el-table", content)
+        self.assertIn("Обновляю данные без сброса таблицы", content)
+
+    def test_dashboard_does_not_send_limit_to_paginated_source_result_api(self):
+        response = self.client.get("/dashboard")
+
+        self.assertEqual(response.status_code, 200)
+        content = response.content.decode()
+        self.assertIn("if (!source.result_list_url) {", content)
+        self.assertIn("query.limit = this.pageSize", content)
+
+    def test_dashboard_humanizes_schedules_and_registry_completeness(self):
+        response = self.client.get("/dashboard")
+
+        self.assertEqual(response.status_code, 200)
+        content = response.content.decode()
+        self.assertIn("function humanizeSchedule", content)
+        self.assertIn("registryCompletenessChart", content)
+        self.assertIn("chart-grid-full", content)
+        self.assertIn("function registryDisplayName", content)
+        self.assertIn('data-main-tab="endpoints"', content)
+        self.assertIn("function buildEndpointCatalog", content)
+        self.assertIn("checkAllEndpointsButton", content)
+        self.assertIn("endpointCheckModal", content)
+        self.assertIn("data-toggle", content)
+        self.assertIn("iconButton", content)
+
+    def test_dashboard_endpoint_checker_uses_row_details_modal(self):
+        response = self.client.get("/dashboard")
+
+        self.assertEqual(response.status_code, 200)
+        content = response.content.decode()
+        self.assertIn("latestEndpointResultMap", content)
+        self.assertIn("endpointCheckSummary", content)
+        self.assertIn("data-endpoint-run", content)
+        self.assertIn("data-endpoint-detail", content)
+        self.assertIn("showEndpointDetail", content)
+        self.assertIn("без данных", content)
diff --git a/tests/apps/parsers/test_views.py b/tests/apps/parsers/test_views.py
index 3c10434..8d60c67 100644
--- a/tests/apps/parsers/test_views.py
+++ b/tests/apps/parsers/test_views.py
@@ -94,6 +94,7 @@ class ParsersViewSetTest(APITestCase):
 
     def test_manufacturers_list_and_retrieve(self):
         record = ManufacturerRecordFactory()
+        second_record = ManufacturerRecordFactory()
         self.client.force_authenticate(self.user)
         url = reverse("api_v1:minpromtorg:manufacturers-list")
         response = self.client.get(url)
@@ -102,6 +103,29 @@ class ParsersViewSetTest(APITestCase):
             reverse("api_v1:minpromtorg:manufacturers-detail", args=[record.id])
         )
         self.assertEqual(detail.status_code, status.HTTP_200_OK)
+        first_page_response = self.client.get(
+            "/api/v1/parsers/results/manufactures/",
+            {"page": 1, "page_size": 1},
+        )
+        second_page_response = self.client.get(
+            "/api/v1/parsers/results/manufactures/",
+            {"page": 2, "page_size": 1},
+        )
+        self.assertEqual(first_page_response.status_code, status.HTTP_200_OK)
+        self.assertEqual(second_page_response.status_code, status.HTTP_200_OK)
+        self.assertEqual(first_page_response.data["meta"]["pagination"]["count"], 2)
+        self.assertEqual(second_page_response.data["meta"]["pagination"]["count"], 2)
+        self.assertNotEqual(
+            first_page_response.data["data"][0]["id"],
+            second_page_response.data["data"][0]["id"],
+        )
+        self.assertEqual(
+            {
+                first_page_response.data["data"][0]["id"],
+                second_page_response.data["data"][0]["id"],
+            },
+            {record.id, second_record.id},
+        )
 
     def test_products_list_and_retrieve(self):
         record = IndustrialProductRecordFactory()
@@ -211,15 +235,15 @@ class ParsersViewSetTest(APITestCase):
         sources = {item["key"]: item for item in payload["sources"]}
         self.assertEqual(
             sources["procurements_44fz"]["result_list_url"],
-            "/api/v1/eis/procurements-44fz/",
+            "/api/v1/parsers/results/procurements_44fz/",
         )
         self.assertEqual(
             sources["procurements_223fz"]["result_list_url"],
-            "/api/v1/eis/procurements-223fz/",
+            "/api/v1/parsers/results/procurements_223fz/",
         )
         self.assertEqual(
             sources["contracts"]["result_list_url"],
-            "/api/v1/eis/contracts/",
+            "/api/v1/parsers/results/contracts/",
         )
         self.assertEqual(
             payload["source_counts"][ParserLoadLog.Source.PROCUREMENTS_44FZ],
@@ -269,6 +293,11 @@ class ParsersViewSetTest(APITestCase):
         )
         self.assertEqual(detail.status_code, status.HTTP_200_OK)
         self.assertIn("lines", detail.data)
+        unified_response = self.client.get("/api/v1/parsers/results/fns_financial/")
+        self.assertEqual(unified_response.status_code, status.HTTP_200_OK)
+        self.assertEqual(unified_response.data["meta"]["pagination"]["count"], 1)
+        self.assertEqual(unified_response.data["data"][0]["id"], report.id)
+        self.assertEqual(unified_response.data["data"][0]["title"], report.file_name)
 
     def test_system_logs_admin_only(self):
         log = ParserLoadLogFactory()