diff --git a/seo_mode/seo_mode/SEO-farm/STAGE_5_8_UX_CONTRACT.md b/seo_mode/seo_mode/SEO-farm/STAGE_5_8_UX_CONTRACT.md
new file mode 100644
index 0000000..b2c77c6
--- /dev/null
+++ b/seo_mode/seo_mode/SEO-farm/STAGE_5_8_UX_CONTRACT.md
@@ -0,0 +1,79 @@
+# NDC SEO mod: UX contract стадий 5-8
+
+Этот документ фиксирует продуктовый смысл середины SEO-pipeline до model review. Цель: оставить Dev Mode доказательным, но не превращать GUI в сырую консоль SEO-инженера.
+
+## Stage 5: Рыночный спрос
+
+Вопрос пользователя: есть ли реальный поисковый спрос по темам сайта?
+
+Основная ценность:
+- показать, какие semantic seeds подтверждены внешним market evidence;
+- показать, какие фразы слабые, шумные, related-only или пустые;
+- отделить deterministic site meaning от реального спроса;
+- подготовить только evidence-backed inputs для SEO-плана страниц.
+
+Dev-details могут показывать Wordstat job, provider readiness, raw rows и external-service gaps. Основной экран не должен выглядеть так, будто строки Wordstat уже являются финальными SEO-решениями.
+
+Выход этапа:
+- подтвержденные сигналы спроса;
+- фразы, требующие проверки;
+- фразы, которые нельзя двигать дальше;
+- недостающие evidence для уверенного решения.
+
+## Stage 6: SEO-план страниц
+
+Вопрос пользователя: что именно SEO-модуль будет улучшать, где и почему?
+
+Основная ценность:
+- разложить approved phrases по страницам, секциям и полям;
+- определить роль: главный интент, дополнительный, поддержка или проверка;
+- задать лимиты естественного использования;
+- сохранить причину и evidence-link для каждого решения;
+- собрать контролируемый contract перед diff/model review.
+
+Это не ручная таблица ключей. Пользователь подтверждает или корректирует предложенные назначения.
+
+Выход этапа:
+- page-level SEO plan;
+- field-level bindings: title, description, H1, body section;
+- materialization queue для planned pages, которых нет в scan;
+- blockers перед rewrite diff.
+
+## Stage 7: Model review
+
+Вопрос пользователя: корректны ли предложенные изменения текста, не уехал ли смысл и есть ли польза?
+
+Основная ценность:
+- ревьюить model-generated variants только после approved SEO-плана;
+- показывать before/after diff по полям и секциям;
+- объяснять, какой intent или keyword закрывает каждое изменение;
+- держать в контексте forbidden claims, project ontology, tone и style limits;
+- требовать human acceptance перед validation/apply.
+
+Выбор модели, provider, plugins и runtime намеренно не решается здесь. Это обсуждаем отдельно только когда diff contract и review interface будут готовы.
+
+Выход этапа:
+- accepted/rejected/edited rewrite variants;
+- unresolved model risks;
+- final working draft candidates для validation.
+
+## Stage 8: Quality gate
+
+Вопрос пользователя: можно ли безопасно применять эти изменения?
+
+Основная ценность:
+- блокировать apply на hard SEO, meaning, style или safety errors;
+- отделять soft warnings от blockers;
+- проверять, что не появились unsupported claims или legacy context;
+- проверять anti-spam, ru-text, structure и pending diff state;
+- давать ясный final apply readiness verdict.
+
+Выход этапа:
+- can apply / cannot apply;
+- hard blockers;
+- accepted warnings;
+- changeset candidate для dry-run/apply.
+
+## Product rule
+
+Dev Mode может показывать raw data, но каждый видимый stage сначала должен отвечать на пользовательское решение. Raw evidence уходит в drill-down details, а не становится главной ценностью экрана.
diff --git a/seo_mode/seo_mode/app/src/App.tsx b/seo_mode/seo_mode/app/src/App.tsx
index bc4535d..e003687 100644
--- a/seo_mode/seo_mode/app/src/App.tsx
+++ b/seo_mode/seo_mode/app/src/App.tsx
@@ -15,6 +15,8 @@ import {
   Image,
   KeyRound,
   Loader2,
+  Maximize2,
+  Minimize2,
   Plug,
   Plus,
   RefreshCw,
@@ -24,41 +26,104 @@ import {
   Server,
   Trash2,
   UploadCloud,
+  UserCircle,
   X
 } from "lucide-react";
-import type { ChangeEvent, DragEvent, FormEvent } from "react";
+import type { CSSProperties, ChangeEvent, DragEvent, FormEvent } from "react";
 import { useEffect, useRef, useState } from "react";
+import { FunnelChart as BklitFunnelChart } from "@bklitui/charts/funnel-chart";
+import { Grid as BklitGrid } from "@bklitui/charts/grid";
+import { HeatmapCells as BklitHeatmapCells } from "@bklitui/charts/heatmap/heatmap-cells";
+import { HeatmapChart as BklitHeatmapChart } from "@bklitui/charts/heatmap/heatmap-chart";
 import {
+  HeatmapInteractionBoundary as BklitHeatmapInteractionBoundary,
+  HeatmapInteractionProvider as BklitHeatmapInteractionProvider
+} from "@bklitui/charts/heatmap/heatmap-context";
+import { RadarArea as BklitRadarArea } from "@bklitui/charts/radar-area";
+import { RadarAxis as BklitRadarAxis } from "@bklitui/charts/radar-axis";
+import { RadarChart as BklitRadarChart } from "@bklitui/charts/radar-chart";
+import { RadarGrid as BklitRadarGrid } from "@bklitui/charts/radar-grid";
+import { RadarLabels as BklitRadarLabels } from "@bklitui/charts/radar-labels";
+import { Ring as BklitRing } from "@bklitui/charts/ring";
+import { RingCenter as BklitRingCenter } from "@bklitui/charts/ring-center";
+import { RingChart as BklitRingChart } from "@bklitui/charts/ring-chart";
+import { Scatter as BklitScatter } from "@bklitui/charts/scatter";
+import { ScatterChart as BklitScatterChart } from "@bklitui/charts/scatter-chart";
+import { XAxis as BklitXAxis } from "@bklitui/charts/x-axis";
+import {
+  applyMaterializationAction,
+  approveKeywordMapDecisions,
   copyProject,
   deleteProject,
   downloadSemanticAnalysisExport,
   fetchExternalServiceSettings,
+  fetchModelProviderStatus,
   fetchHealth,
+  fetchLatestKeywordCleaning,
+  fetchLatestKeywordMap,
+  fetchLatestMaterialization,
   fetchLatestMarketEnrichment,
+  fetchLatestProjectOntology,
+  fetchLatestRewriteDiff,
+  fetchLatestRewritePlan,
   fetchLatestSemanticAnalysis,
+  fetchLatestSeoContextReview,
   fetchLatestProjectScan,
+  fetchLatestSeoStrategy,
+  fetchLatestSerpInterpretation,
+  fetchLatestStrategyQualityReview,
+  fetchLatestStrategySynthesis,
+  fetchLatestYandexEvidence,
   fetchProjects,
   getPreviewPageUrl,
   importBrowserFolder,
   openPageWorkspace,
+  probeYandexAiStudioCredential,
   renameProject,
   resetPageWorkspace,
   runMarketEnrichment,
   runProjectScan,
   runSemanticAnalysis,
+  runYandexEvidence,
+  runSerpInterpretation,
+  runStrategyQualityReview,
+  runStrategySynthesis,
+  runSeoContextReview,
+  runSeoModelTask,
   savePageWorkspace,
   updateExternalServiceSettings,
+  updateProjectOntologyApproval,
+  updateProjectOntologyConfirmations,
   updateProjectPageSelection,
   type BrowserFolderFileInput,
   type ExternalServiceSettings,
   type ExternalServiceUpdateInput,
   type HealthResponse,
+  type KeywordCleaningContract,
+  type KeywordMapContract,
+  type MaterializationActionInput,
+  type MaterializationContract,
   type MarketEnrichmentContract,
   type PageWorkspace,
+  type YandexAiStudioProbe,
   type ProjectScanSummary,
   type ProjectSummary,
+  type ProjectOntologyApprovalStatus,
+  type ProjectOntologyVersion,
+  type RewriteDiffContract,
+  type RewritePlanContract,
+  type SeoContextReviewRun,
+  type SeoStrategyContract,
+  type SeoModelProviderStatusContract,
+  type SeoModelTaskRun,
+  type SeoModelTaskType,
+  type SeoNormalizationContract,
+  type SerpInterpretationContract,
   type SemanticAnalysisRun,
-  type SemanticExportFormat
+  type SemanticExportFormat,
+  type StrategyQualityReviewContract,
+  type StrategySynthesisContract,
+  type YandexEvidenceContract
 } from "./api";
 import ProjectScopeFlow from "./ProjectScopeFlow";
 import "./styles.css";
@@ -67,11 +132,11 @@ const pipeline = [
   "Источник проекта",
   "Конфигурация проекта",
   "Рабочая зона страницы",
-  "Семантика",
-  "Сбор частотности",
-  "Карта ключей",
-  "Рерайт",
-  "Валидация",
+  "Контекст сайта",
+  "Рыночный спрос",
+  "SEO-план",
+  "Стратегия",
+  "Проверка качества",
   "Применение"
 ];
 
@@ -96,37 +161,69 @@ const stageMeta = [
     description: "Открываем preview, секции страницы и draft-редактор без изменения исходного сайта."
   },
   {
-    title: "Семантический анализ",
-    sectionTitle: "SEO-аналитика",
-    description: "Считаем покрытие продуктовой онтологии NodeDC, legacy-мусор, gaps и стартовые сиды."
+    title: "Контекст сайта",
+    sectionTitle: "Анализ контекста",
+    description: "Собираем, что сайт реально говорит, где уверенность слабая и какие фразы можно проверять рынком."
   },
   {
-    title: "Сбор частотности",
-    sectionTitle: "Сбор частотности",
-    description: "Будущий этап проверки сидов и ключей через частотность."
+    title: "Рыночный спрос",
+    sectionTitle: "Рыночный спрос",
+    description: "Проверяем, есть ли внешний спрос по темам сайта, и отделяем подтвержденные фразы от шума."
   },
   {
-    title: "Карта ключей",
-    sectionTitle: "Карта ключей",
-    description: "Будущий этап распределения ключей по страницам и секциям."
+    title: "SEO-план страниц",
+    sectionTitle: "SEO-план страниц",
+    description: "Фиксируем, что улучшать на страницах: поле, роль фразы, лимит и причину решения."
   },
   {
-    title: "Рерайт",
-    sectionTitle: "Рерайт",
-    description: "Будущий этап подготовки правок текста и meta-полей."
+    title: "Стратегия",
+    sectionTitle: "SEO-стратегия",
+    description: "Собираем доказанную карту возможностей, рисков и недостающих внешних данных без правки сайта."
   },
   {
-    title: "Валидация",
-    sectionTitle: "Валидация",
-    description: "Будущий этап проверки качества изменений перед применением."
+    title: "Проверка качества",
+    sectionTitle: "Проверка качества",
+    description: "Финальный контроль перед применением: смысл, переспам, стиль, факты, правки и блокеры."
   },
   {
     title: "Применение",
     sectionTitle: "Применение",
-    description: "Будущий безопасный Apply с diff и контролем конфликтов."
+    description: "Будущее безопасное применение правок с контролем конфликтов."
   }
 ];
 
+const stageDecisionFrames: Partial<
+  Record<
+    number,
+    {
+      gate: string;
+      question: string;
+      result: string;
+    }
+  >
+> = {
+  4: {
+    gate: "Дальше идут только фразы с доказательствами.",
+    question: "Есть ли реальный спрос по темам сайта?",
+    result: "Подтвержденные фразы, слабые сигналы, шум и недостающие проверки."
+  },
+  5: {
+    gate: "До стратегии нужен зафиксированный план страниц, спроса и evidence.",
+    question: "Что именно улучшать на страницах и почему?",
+    result: "Страница, роль фразы, причина, доказательства и ограничения по данным."
+  },
+  6: {
+    gate: "Сайт не меняем: сначала доказываем полезность стратегии.",
+    question: "Где есть рост, где риск, каких данных не хватает?",
+    result: "Opportunity map, evidence gaps, риски и варианты следующей SEO-стратегии."
+  },
+  7: {
+    gate: "Применение невозможно без зелёного вердикта проверки.",
+    question: "Можно ли применять будущие изменения?",
+    result: "Критичные блокеры, предупреждения, проверка смысла/стиля и готовность к применению."
+  }
+};
+
 const AUDIT_ISSUE_PAGE_SIZE = 8;
 const NOTICE_AUTO_HIDE_MS = 8000;
 
@@ -148,6 +245,1790 @@ function formatCount(value: number | null) {
   return value === null ? "n/a" : numberFormatter.format(value);
 }
 
+type SeoChartTone = "good" | "neutral" | "problem" | "warning";
+
+type SeoChartDatum = {
+  label: string;
+  value: number;
+  detail?: string;
+  tone?: SeoChartTone;
+};
+
+type SeoScatterPoint = {
+  detail?: string;
+  id: string;
+  label: string;
+  size?: number;
+  tone?: SeoChartTone;
+  x: number;
+  y: number;
+};
+
+type SeoMatrixDatum = {
+  columns: Array<{ key: string; label: string }>;
+  rows: Array<{
+    cells: Record<string, number>;
+    detail?: string;
+    key: string;
+    label: string;
+  }>;
+};
+
+type SeoNormalizationSeedView = SeoNormalizationContract["seedStrategy"][number];
+type KeywordCleaningItemView = KeywordCleaningContract["items"][number];
+type KeywordMapItemView = KeywordMapContract["items"][number];
+type KeywordPagePlanStatus = "blocked" | "ready" | "review";
+
+function clampChartValue(value: number, min: number, max: number) {
+  return Math.min(max, Math.max(min, Number.isFinite(value) ? value : min));
+}
+
+function getChartPercent(value: number, max: number) {
+  if (max <= 0) {
+    return 0;
+  }
+
+  return clampChartValue(Math.round((value / max) * 100), 0, 100);
+}
+
+function getChartToneClass(tone: SeoChartTone | undefined) {
+  return `tone-${tone ?? "neutral"}`;
+}
+
+function getChartToneColor(tone: SeoChartTone | undefined) {
+  if (tone === "good") return "#2f6b4f";
+  if (tone === "warning") return "#b2771f";
+  if (tone === "problem") return "#8b2f2f";
+  return "#536879";
+}
+
+function getSeoSeedReviewShortLabel(seed: SeoNormalizationSeedView) {
+  if (seed.review.status === "auto_approved") {
+    return seed.review.sendToSerp ? "approved · Wordstat + SERP" : "approved · Wordstat";
+  }
+
+  if (seed.review.status === "rejected") {
+    return "отсечено";
+  }
+
+  return "нужна проверка";
+}
+
+function getSemanticScoreBars(analysis: SemanticAnalysisRun): SeoChartDatum[] {
+  return [
+    {
+      detail: "общая готовность",
+      label: "Покрытие",
+      tone: analysis.summary.coverageScore >= 70 ? "good" : analysis.summary.coverageScore >= 45 ? "warning" : "problem",
+      value: analysis.summary.coverageScore
+    },
+    {
+      detail: "лексика",
+      label: "Лексика",
+      tone:
+        (analysis.summary.lexicalCoverageScore ?? analysis.summary.coverageScore) >= 70
+          ? "good"
+          : (analysis.summary.lexicalCoverageScore ?? analysis.summary.coverageScore) >= 45
+            ? "warning"
+            : "problem",
+      value: analysis.summary.lexicalCoverageScore ?? analysis.summary.coverageScore
+    },
+    {
+      detail: "доказательность",
+      label: "Опора",
+      tone:
+        (analysis.summary.evidenceScore ?? analysis.summary.coverageScore) >= 70
+          ? "good"
+          : (analysis.summary.evidenceScore ?? analysis.summary.coverageScore) >= 45
+            ? "warning"
+            : "problem",
+      value: analysis.summary.evidenceScore ?? analysis.summary.coverageScore
+    },
+    {
+      detail: "интенты",
+      label: "Интенты",
+      tone:
+        (analysis.summary.intentCoverageScore ?? analysis.summary.coverageScore) >= 70
+          ? "good"
+          : (analysis.summary.intentCoverageScore ?? analysis.summary.coverageScore) >= 45
+            ? "warning"
+            : "problem",
+      value: analysis.summary.intentCoverageScore ?? analysis.summary.coverageScore
+    },
+    {
+      detail: "коммерческий слой",
+      label: "Коммерция",
+      tone:
+        (analysis.summary.commercialReadinessScore ?? analysis.summary.coverageScore) >= 70
+          ? "good"
+          : (analysis.summary.commercialReadinessScore ?? analysis.summary.coverageScore) >= 45
+            ? "warning"
+            : "problem",
+      value: analysis.summary.commercialReadinessScore ?? analysis.summary.coverageScore
+    }
+  ];
+}
+
+function getSemanticClusterBars(analysis: SemanticAnalysisRun): SeoChartDatum[] {
+  return [
+    {
+      detail: "уже читается",
+      label: "Покрыто",
+      tone: "good",
+      value: analysis.summary.coveredClusters
+    },
+    {
+      detail: "требует усиления",
+      label: "Слабо",
+      tone: "warning",
+      value: analysis.summary.weakClusters
+    },
+    {
+      detail: "нет достаточного контента",
+      label: "Пусто",
+      tone: "problem",
+      value: analysis.summary.missingClusters
+    },
+    {
+      detail: "seed phrases",
+      label: "Seeds",
+      tone: "neutral",
+      value: analysis.summary.seedCandidates
+    }
+  ];
+}
+
+function getMarketSignalCount(market: MarketEnrichmentContract) {
+  return (market.wordstat.summary.exactFrequencySeedCount ?? 0) + (market.wordstat.summary.relatedOnlySeedCount ?? 0);
+}
+
+function getMarketDecision(market: MarketEnrichmentContract) {
+  const approvedCount = market.readiness.seedCount;
+  const collectedCount = market.wordstat.summary.collectedSeedCount;
+  const signalCount = getMarketSignalCount(market);
+  const reviewCount = market.normalization.readiness.needsHumanReviewCount;
+
+  if (!market.readiness.ontologyReadyForMarket) {
+    return {
+      action: "Сначала закрепить project ontology, иначе market evidence будет привязан к неподтверждённому смыслу сайта.",
+      label: "контекст не готов",
+      summary: "Рыночный спрос пока нельзя считать рабочим evidence.",
+      tone: "problem" as const
+    };
+  }
+
+  if (approvedCount === 0) {
+    return {
+      action: "Нужен model/human review seed strategy: сейчас нет фраз, которые можно безопасно отправить во внешний рынок.",
+      label: "нет очереди",
+      summary: "Market Demand заблокирован до нормализации.",
+      tone: "problem" as const
+    };
+  }
+
+  if (collectedCount === 0) {
+    return {
+      action: `Запустить Wordstat collection по ${approvedCount} approved фразам, потом решать keyword map.`,
+      label: "готово к сбору",
+      summary: "Контекст уже сужен до approved queue, но внешнего evidence ещё нет.",
+      tone: "warning" as const
+    };
+  }
+
+  if (collectedCount < approvedCount) {
+    return {
+      action: `Запустить Wordstat collection для оставшихся ${approvedCount - collectedCount} approved фраз, затем решать SEO-план.`,
+      label: "сбор неполный",
+      summary: `${collectedCount}/${approvedCount} approved фраз имеют Wordstat evidence.`,
+      tone: "warning" as const
+    };
+  }
+
+  if (signalCount === 0) {
+    return {
+      action: `Не строить SEO-план на текущих фразах. Сначала отдать ${reviewCount} спорных фраз в model/human review и расширить seed strategy.`,
+      label: "спрос не доказан",
+      summary: `${collectedCount} approved фраз проверены, но Wordstat не дал точного или related сигнала.`,
+      tone: "problem" as const
+    };
+  }
+
+  return {
+    action:
+      reviewCount > 0
+        ? `Двигать в SEO-план только ${signalCount} подтверждённых фраз, остальные ${reviewCount} оставить в review.`
+        : "Можно передавать подтверждённые фразы в SEO-план и готовить SERP evidence.",
+    label: "есть спрос",
+    summary: `${signalCount}/${approvedCount} approved фраз имеют рыночный сигнал.`,
+    tone: "good" as const
+  };
+}
+
+function getMarketEvidenceCards(market: MarketEnrichmentContract): SeoChartDatum[] {
+  return [
+    {
+      detail: "approved queue",
+      label: "К проверке",
+      tone: "neutral",
+      value: market.readiness.seedCount
+    },
+    {
+      detail: "получили Wordstat row",
+      label: "Проверено",
+      tone: market.wordstat.summary.collectedSeedCount > 0 ? "good" : "warning",
+      value: market.wordstat.summary.collectedSeedCount
+    },
+    {
+      detail: "точный или related signal",
+      label: "Спрос",
+      tone: getMarketSignalCount(market) > 0 ? "good" : "problem",
+      value: getMarketSignalCount(market)
+    },
+    {
+      detail: "не подтвердились",
+      label: "Пусто",
+      tone: (market.wordstat.summary.noSignalSeedCount ?? 0) > 0 ? "problem" : "neutral",
+      value: market.wordstat.summary.noSignalSeedCount ?? 0
+    },
+    {
+      detail: "не пускать дальше без модели",
+      label: "Review",
+      tone: market.normalization.readiness.needsHumanReviewCount > 0 ? "warning" : "neutral",
+      value: market.normalization.readiness.needsHumanReviewCount
+    }
+  ];
+}
+
+function getMarketDemandComposition(market: MarketEnrichmentContract): SeoChartDatum[] {
+  const signalCount = getMarketSignalCount(market);
+  const noSignalCount = market.wordstat.summary.noSignalSeedCount ?? 0;
+  const pendingCount = Math.max(0, market.readiness.seedCount - market.wordstat.summary.collectedSeedCount);
+
+  return [
+    {
+      detail: "точный или related спрос",
+      label: "Сигнал",
+      tone: signalCount > 0 ? "good" : "neutral",
+      value: signalCount
+    },
+    {
+      detail: "проверено без спроса",
+      label: "Пусто",
+      tone: noSignalCount > 0 ? "problem" : "neutral",
+      value: noSignalCount
+    },
+    {
+      detail: "approved, но ещё без job",
+      label: "Дособрать",
+      tone: pendingCount > 0 ? "warning" : "neutral",
+      value: pendingCount
+    }
+  ];
+}
+
+function getMarketReadinessRadar(market: MarketEnrichmentContract): SeoChartDatum[] {
+  const normalizedCount = market.normalization.readiness.normalizedSeedCount;
+  const wordstatApprovedCount = market.normalization.readiness.wordstatApprovedCount;
+  const reviewCount = market.normalization.readiness.needsHumanReviewCount;
+  const seedCount = market.readiness.seedCount;
+  const signalCount = getMarketSignalCount(market);
+  const wordstatProvider = market.providers.find((provider) => provider.id === "wordstat");
+  const serpProvider = market.providers.find((provider) => provider.id === "serp");
+
+  return [
+    {
+      detail: "approved ontology",
+      label: "Контекст",
+      tone: market.readiness.ontologyReadyForMarket ? "good" : "problem",
+      value: market.readiness.ontologyReadyForMarket ? 100 : 0
+    },
+    {
+      detail: "Wordstat queue",
+      label: "Очередь",
+      tone: wordstatApprovedCount > 0 ? "good" : "warning",
+      value: getChartPercent(wordstatApprovedCount, Math.max(normalizedCount, 1))
+    },
+    {
+      detail: "собрано по approved",
+      label: "Сбор",
+      tone: market.wordstat.summary.collectedSeedCount >= seedCount && seedCount > 0 ? "good" : "warning",
+      value: getChartPercent(market.wordstat.summary.collectedSeedCount, Math.max(seedCount, 1))
+    },
+    {
+      detail: "подтвержденный спрос",
+      label: "Сигнал",
+      tone: signalCount > 0 ? "good" : "problem",
+      value: getChartPercent(signalCount, Math.max(seedCount, 1))
+    },
+    {
+      detail: "меньше спорных фраз",
+      label: "Review clear",
+      tone: reviewCount === 0 ? "good" : "warning",
+      value: 100 - getChartPercent(reviewCount, Math.max(normalizedCount, 1))
+    },
+    {
+      detail: "внешние providers",
+      label: "Providers",
+      tone: wordstatProvider?.status === "connected" || serpProvider?.status === "connected" ? "good" : "warning",
+      value:
+        (wordstatProvider?.status === "connected" ? 50 : 0) +
+        (serpProvider?.status === "connected" ? 50 : 0)
+    }
+  ];
+}
+
+function getMarketFunnelData(
+  market: MarketEnrichmentContract,
+  keywordMap: KeywordMapContract | null | undefined
+): SeoChartDatum[] {
+  return [
+    {
+      detail: "из контекста сайта",
+      label: "Фразы",
+      tone: "neutral",
+      value: market.readiness.seedCount
+    },
+    {
+      detail: "прошли сбор",
+      label: "Проверено",
+      tone: market.wordstat.summary.collectedSeedCount > 0 ? "good" : "warning",
+      value: market.wordstat.summary.collectedSeedCount
+    },
+    {
+      detail: "точный или смежный сигнал",
+      label: "Спрос",
+      tone: getMarketSignalCount(market) > 0 ? "good" : "warning",
+      value: getMarketSignalCount(market)
+    },
+    {
+      detail: "попало в SEO-план",
+      label: "Назначено",
+      tone: (keywordMap?.readiness.mappedItemCount ?? 0) > 0 ? "good" : "neutral",
+      value: keywordMap?.readiness.mappedItemCount ?? 0
+    }
+  ];
+}
+
+function getMarketFrequencyBars(market: MarketEnrichmentContract): SeoChartDatum[] {
+  return [
+    {
+      detail: "верхний спрос",
+      label: "Сильный",
+      tone: "good",
+      value: market.wordstat.summary.highFrequencyCount
+    },
+    {
+      detail: "средний спрос",
+      label: "Средний",
+      tone: "warning",
+      value: market.wordstat.summary.midFrequencyCount
+    },
+    {
+      detail: "низкий спрос",
+      label: "Низкий",
+      tone: "neutral",
+      value: market.wordstat.summary.lowFrequencyCount
+    },
+    {
+      detail: "без частотности",
+      label: "Пусто",
+      tone: "problem",
+      value: market.wordstat.summary.noSignalSeedCount ?? 0
+    }
+  ];
+}
+
+function getNormalizationReviewFunnelData(market: MarketEnrichmentContract): SeoChartDatum[] {
+  return [
+    {
+      detail: "после semantic cleanup",
+      label: "Нормализовано",
+      tone: "neutral",
+      value: market.normalization.readiness.normalizedSeedCount
+    },
+    {
+      detail: "можно собирать без модели",
+      label: "Auto",
+      tone: "good",
+      value: market.normalization.readiness.autoApprovedCount
+    },
+    {
+      detail: "уйдёт во внешний спрос",
+      label: "Wordstat",
+      tone: market.normalization.readiness.wordstatApprovedCount > 0 ? "good" : "warning",
+      value: market.normalization.readiness.wordstatApprovedCount
+    },
+    {
+      detail: "требует model/human review",
+      label: "Review",
+      tone: market.normalization.readiness.needsHumanReviewCount > 0 ? "warning" : "neutral",
+      value: market.normalization.readiness.needsHumanReviewCount
+    },
+    {
+      detail: "не пускать в рынок",
+      label: "Отсечено",
+      tone: market.normalization.readiness.rejectedSeedCount > 0 ? "problem" : "neutral",
+      value: market.normalization.readiness.rejectedSeedCount
+    }
+  ];
+}
+
+function getMarketEvidenceTone(status: MarketEnrichmentContract["seedQueue"][number]["evidenceStatus"]): SeoChartTone {
+  if (status === "collected") return "good";
+  if (status === "collected_related_only" || status === "ready_for_collection") return "warning";
+  if (status === "collection_failed" || status === "not_configured") return "problem";
+  return "neutral";
+}
+
+function getPriorityScore(priority: "high" | "medium" | "low") {
+  if (priority === "high") return 90;
+  if (priority === "medium") return 58;
+  return 30;
+}
+
+function getMarketOpportunityPoints(market: MarketEnrichmentContract): SeoScatterPoint[] {
+  return market.seedQueue
+    .filter((seed) => seed.frequency !== null || seed.relatedCount > 0)
+    .slice(0, 24)
+    .map((seed) => {
+      const demand = seed.frequency ?? seed.relatedCount;
+      const evidenceBonus = seed.evidenceStatus === "collected" ? 10 : seed.evidenceStatus === "collected_related_only" ? 5 : 0;
+
+      return {
+        detail: `${seed.clusterTitle} · ${formatCount(seed.frequency)} · related ${seed.relatedCount}`,
+        id: `${seed.clusterId}:${seed.phrase}`,
+        label: seed.phrase,
+        size: seed.relatedCount,
+        tone: getMarketEvidenceTone(seed.evidenceStatus),
+        x: Math.max(1, demand),
+        y: clampChartValue(getPriorityScore(seed.priority) + evidenceBonus, 0, 100)
+      };
+    });
+}
+
+function getKeywordCleaningDecisionLabel(decision: KeywordCleaningItemView["decision"]) {
+  const labels = {
+    article: "контент",
+    risky: "проверить",
+    support: "поддержка",
+    trash: "мусор",
+    use: "в план"
+  };
+
+  return labels[decision];
+}
+
+function getKeywordCleaningSourceLabel(source: KeywordCleaningItemView["source"]) {
+  const labels = {
+    manual: "manual",
+    normalization_seed: "seed",
+    serp: "SERP",
+    wordstat_related: "related",
+    wordstat_seed: "Wordstat"
+  };
+
+  return labels[source];
+}
+
+function getKeywordCleaningTone(decision: KeywordCleaningItemView["decision"]): SeoChartTone {
+  if (decision === "use" || decision === "support") return "good";
+  if (decision === "article" || decision === "risky") return "warning";
+  return "problem";
+}
+
+function getKeywordCleaningFunnelData(cleaning: KeywordCleaningContract): SeoChartDatum[] {
+  return [
+    {
+      detail: "market + Wordstat",
+      label: "Источник",
+      tone: "neutral",
+      value: cleaning.readiness.sourcePhraseCount
+    },
+    {
+      detail: "можно в карту",
+      label: "Use/support",
+      tone: cleaning.readiness.keywordMapCandidateCount > 0 ? "good" : "warning",
+      value: cleaning.readiness.keywordMapCandidateCount
+    },
+    {
+      detail: "контентный backlog",
+      label: "Контент",
+      tone: cleaning.readiness.articleCount > 0 ? "warning" : "neutral",
+      value: cleaning.readiness.articleCount
+    },
+    {
+      detail: "нужна проверка",
+      label: "Risky",
+      tone: cleaning.readiness.riskyCount > 0 ? "warning" : "neutral",
+      value: cleaning.readiness.riskyCount
+    },
+    {
+      detail: "не пускать дальше",
+      label: "Trash",
+      tone: cleaning.readiness.trashCount > 0 ? "problem" : "neutral",
+      value: cleaning.readiness.trashCount
+    }
+  ];
+}
+
+function getKeywordCleaningDemandPoints(cleaning: KeywordCleaningContract): SeoScatterPoint[] {
+  return cleaning.items
+    .filter((item) => item.frequency !== null || item.relatedCount > 0)
+    .slice(0, 28)
+    .map((item) => ({
+      detail: `${getKeywordCleaningDecisionLabel(item.decision)} · ${item.targetPath ?? "без страницы"} · ${item.reason}`,
+      id: item.id,
+      label: item.phrase,
+      size: item.relatedCount,
+      tone: getKeywordCleaningTone(item.decision),
+      x: Math.max(1, item.frequency ?? item.relatedCount),
+      y: clampChartValue(Math.round(item.confidence * 100), 0, 100)
+    }));
+}
+
+function getKeywordFunnelData(keywordMap: KeywordMapContract): SeoChartDatum[] {
+  return [
+    {
+      detail: "из рыночной проверки",
+      label: "Фразы",
+      tone: "neutral",
+      value: keywordMap.readiness.seedCount
+    },
+    {
+      detail: "имеют страницу",
+      label: "Назначено",
+      tone: keywordMap.readiness.mappedItemCount > 0 ? "good" : "warning",
+      value: keywordMap.readiness.mappedItemCount
+    },
+    {
+      detail: "с рыночным сигналом",
+      label: "Спрос",
+      tone: keywordMap.readiness.marketEvidenceCount > 0 ? "good" : "warning",
+      value: keywordMap.readiness.marketEvidenceCount
+    },
+    {
+      detail: "готово к фиксации",
+      label: "Готово",
+      tone: keywordMap.readiness.persistableItemCount > 0 ? "good" : "neutral",
+      value: keywordMap.readiness.persistableItemCount
+    },
+    {
+      detail: "approved decisions",
+      label: "Зафиксировано",
+      tone: keywordMap.persisted.approvedDecisionCount > 0 ? "good" : "neutral",
+      value: keywordMap.persisted.approvedDecisionCount
+    }
+  ];
+}
+
+function getKeywordRoleBars(keywordMap: KeywordMapContract): SeoChartDatum[] {
+  const counts = keywordMap.items.reduce<Record<string, number>>((accumulator, item) => {
+    accumulator[item.role] = (accumulator[item.role] ?? 0) + 1;
+    return accumulator;
+  }, {});
+
+  return (["primary", "secondary", "support", "validate"] as const).map((role) => ({
+    detail: getKeywordMapRoleLabel(role),
+    label: getKeywordMapRoleLabel(role),
+    tone: role === "primary" ? "good" : role === "validate" ? "warning" : "neutral",
+    value: counts[role] ?? 0
+  }));
+}
+
+function getKeywordTargetBars(keywordMap: KeywordMapContract): SeoChartDatum[] {
+  const counts = keywordMap.items.reduce<Record<string, number>>((accumulator, item) => {
+    const key = item.targetPath ?? "target pending";
+    accumulator[key] = (accumulator[key] ?? 0) + 1;
+    return accumulator;
+  }, {});
+
+  return Object.entries(counts)
+    .sort((left, right) => right[1] - left[1])
+    .slice(0, 6)
+    .map(([label, value]) => ({
+      detail: "привязки к страницам",
+      label: label === "target pending" ? "без страницы" : label,
+      tone: label === "target pending" ? "warning" : "good",
+      value
+    }));
+}
+
+function getKeywordRoleMatrix(keywordMap: KeywordMapContract): SeoMatrixDatum {
+  const shortRoleLabels = {
+    primary: "главн.",
+    secondary: "доп.",
+    support: "подд.",
+    validate: "пров."
+  };
+  const columns = (["primary", "secondary", "support", "validate"] as const).map((role) => ({
+    key: role,
+    label: shortRoleLabels[role]
+  }));
+  const targetRows = keywordMap.items.reduce<Record<string, Record<string, number>>>((accumulator, item) => {
+    const target = item.targetPath ?? "target pending";
+    accumulator[target] ??= {};
+    accumulator[target][item.role] = (accumulator[target][item.role] ?? 0) + 1;
+    return accumulator;
+  }, {});
+
+  const rows = Object.entries(targetRows)
+    .sort((left, right) => {
+      const leftTotal = Object.values(left[1]).reduce((sum, value) => sum + value, 0);
+      const rightTotal = Object.values(right[1]).reduce((sum, value) => sum + value, 0);
+      return rightTotal - leftTotal;
+    })
+    .slice(0, 7)
+    .map(([target, cells]) => ({
+      cells,
+      detail: target === "target pending" ? "нет page binding" : "page binding",
+      key: target,
+      label: target === "target pending" ? "без страницы" : target
+    }));
+
+  return { columns, rows };
+}
+
+function isKeywordPlanItemPersistable(item: KeywordMapItemView) {
+  return (
+    item.role !== "validate" &&
+    item.evidenceStatus === "collected" &&
+    item.frequency !== null &&
+    Boolean(item.projectOntologyVersionId) &&
+    Boolean(item.wordstatResultId)
+  );
+}
+
+function getKeywordRoleFieldLabel(role: KeywordMapItemView["role"]) {
+  const labels = {
+    primary: "title / H1",
+    secondary: "meta description",
+    support: "body section",
+    validate: "review lane"
+  };
+
+  return labels[role];
+}
+
+function getKeywordPlanDecision(keywordMap: KeywordMapContract) {
+  const reviewCount = keywordMap.items.filter((item) => !isKeywordPlanItemPersistable(item)).length;
+  const targetlessCount = keywordMap.items.filter((item) => !item.targetPath).length;
+  const exactEvidenceCount = keywordMap.items.filter((item) => item.evidenceStatus === "collected" && item.frequency !== null).length;
+  const safePageCount = new Set(
+    keywordMap.items.filter(isKeywordPlanItemPersistable).map((item) => item.targetPath).filter(Boolean)
+  ).size;
+
+  if (keywordMap.state === "blocked" || !keywordMap.readiness.reviewedOntology) {
+    return {
+      action:
+        "Сначала закрываем blockers и reviewed ontology. До этого keyword map нельзя считать доказанной базой стратегии.",
+      label: "нельзя фиксировать",
+      metrics: [
+        { detail: "контекст не подтверждён", label: "Ontology", tone: "problem" as SeoChartTone, value: 0 },
+        { detail: "page binding", label: "Страниц", tone: "neutral" as SeoChartTone, value: safePageCount },
+        { detail: "exact Wordstat", label: "Evidence", tone: "neutral" as SeoChartTone, value: exactEvidenceCount },
+        { detail: "ручная очередь", label: "Review", tone: "warning" as SeoChartTone, value: reviewCount }
+      ],
+      summary:
+        "Сейчас это диагностический черновик: он показывает, где фразы могли бы лечь, но не имеет права закреплять решения.",
+      title: "План заблокирован контекстом",
+      tone: "problem" as SeoChartTone
+    };
+  }
+
+  if (keywordMap.readiness.persistableItemCount > 0) {
+    return {
+      action:
+        "Фиксируем только exact Wordstat + page binding; validate/no-signal остаются вне rewrite и ждут ручной проверки.",
+      label: "можно фиксировать",
+      metrics: [
+        {
+          detail: "approved decisions",
+          label: "Фиксировать",
+          tone: "good" as SeoChartTone,
+          value: keywordMap.readiness.persistableItemCount
+        },
+        { detail: "страницы с безопасными решениями", label: "Страниц", tone: "good" as SeoChartTone, value: safePageCount },
+        { detail: "останется в ручной проверке", label: "Review", tone: "warning" as SeoChartTone, value: reviewCount },
+        { detail: "без page binding", label: "Без страницы", tone: "warning" as SeoChartTone, value: targetlessCount }
+      ],
+      summary: `${keywordMap.readiness.persistableItemCount} из ${keywordMap.readiness.seedCount} фраз можно закрепить как безопасные решения. Остальное не должно автоматически попадать в текст.`,
+      title: `Можно закрепить ${keywordMap.readiness.persistableItemCount} SEO-решения`,
+      tone: "good" as SeoChartTone
+    };
+  }
+
+  return {
+    action:
+      "Дальше нужно усилить Wordstat/страничные привязки: без exact evidence план остаётся картой проверки, а не заданием на rewrite.",
+    label: "только review",
+    metrics: [
+      {
+        detail: "exact Wordstat",
+        label: "Evidence",
+        tone: (exactEvidenceCount > 0 ? "warning" : "problem") as SeoChartTone,
+        value: exactEvidenceCount
+      },
+      {
+        detail: "page binding",
+        label: "Назначено",
+        tone: (keywordMap.readiness.mappedItemCount > 0 ? "warning" : "problem") as SeoChartTone,
+        value: keywordMap.readiness.mappedItemCount
+      },
+      { detail: "ручная очередь", label: "Review", tone: "warning" as SeoChartTone, value: reviewCount },
+      { detail: "без page binding", label: "Без страницы", tone: "warning" as SeoChartTone, value: targetlessCount }
+    ],
+    summary:
+      "План уже показывает направления по страницам, но пока не даёт безопасных approved decisions для следующего этапа.",
+    title: "Фиксация пока не готова",
+    tone: "warning" as SeoChartTone
+  };
+}
+
+function getKeywordPlanPageSummaries(keywordMap: KeywordMapContract) {
+  const roleRank: Record<KeywordMapItemView["role"], number> = {
+    primary: 0,
+    secondary: 1,
+    support: 2,
+    validate: 3
+  };
+  const groups = keywordMap.items.reduce<Map<string, KeywordMapItemView[]>>((accumulator, item) => {
+    const key = item.targetPath ?? "target pending";
+    const group = accumulator.get(key) ?? [];
+    group.push(item);
+    accumulator.set(key, group);
+    return accumulator;
+  }, new Map());
+
+  return Array.from(groups.entries())
+    .map(([targetPath, items]) => {
+      const counts = items.reduce<Record<KeywordMapItemView["role"], number>>(
+        (accumulator, item) => {
+          accumulator[item.role] += 1;
+          return accumulator;
+        },
+        { primary: 0, secondary: 0, support: 0, validate: 0 }
+      );
+      const persistableItems = items.filter(isKeywordPlanItemPersistable);
+      const reviewItems = items.filter((item) => !isKeywordPlanItemPersistable(item));
+      const evidenceCount = items.filter((item) => item.evidenceStatus === "collected").length;
+      const topItems = [...items].sort((left, right) => {
+        const persistableDelta = Number(isKeywordPlanItemPersistable(right)) - Number(isKeywordPlanItemPersistable(left));
+
+        if (persistableDelta !== 0) {
+          return persistableDelta;
+        }
+
+        const roleDelta = roleRank[left.role] - roleRank[right.role];
+
+        if (roleDelta !== 0) {
+          return roleDelta;
+        }
+
+        return (right.frequency ?? 0) - (left.frequency ?? 0);
+      });
+      const primaryItem = topItems.find((item) => item.role === "primary") ?? topItems[0] ?? null;
+      const readableTarget = targetPath === "target pending" ? "без страницы" : targetPath;
+      const status: KeywordPagePlanStatus =
+        targetPath === "target pending"
+          ? "blocked"
+          : persistableItems.length > 0
+            ? "ready"
+            : evidenceCount > 0
+              ? "review"
+              : "blocked";
+      const statusLabel =
+        status === "ready" ? "можно фиксировать" : status === "review" ? "ручная проверка" : "не отдавать в rewrite";
+      const action =
+        status === "ready"
+          ? `Закрепить ${persistableItems.length} подтверждённые фразы и не тащить review-хвост в rewrite.`
+          : targetPath === "target pending"
+            ? "Сначала выбрать посадочную или создать страницу, потом пересобрать привязку."
+            : "Проверить формулировки и market evidence перед закреплением.";
+
+      return {
+        action,
+        counts,
+        evidenceCount,
+        key: targetPath,
+        primaryItem,
+        readableTarget,
+        reviewItems,
+        status,
+        statusLabel,
+        targetPath: targetPath === "target pending" ? null : targetPath,
+        topItems
+      };
+    })
+    .sort((left, right) => {
+      const statusRank: Record<KeywordPagePlanStatus, number> = { ready: 0, review: 1, blocked: 2 };
+      const statusDelta = statusRank[left.status] - statusRank[right.status];
+
+      if (statusDelta !== 0) {
+        return statusDelta;
+      }
+
+      return right.topItems.length - left.topItems.length;
+    })
+    .slice(0, 8);
+}
+
+function getKeywordPlanReviewItems(keywordMap: KeywordMapContract) {
+  return keywordMap.items
+    .filter((item) => !isKeywordPlanItemPersistable(item))
+    .sort((left, right) => {
+      const frequencyDelta = (right.frequency ?? 0) - (left.frequency ?? 0);
+
+      if (frequencyDelta !== 0) {
+        return frequencyDelta;
+      }
+
+      return left.phrase.localeCompare(right.phrase, "ru");
+    });
+}
+
+function getRewriteReadinessFunnelData(
+  rewritePlan: RewritePlanContract,
+  rewriteDiff: RewriteDiffContract | null | undefined
+): SeoChartDatum[] {
+  return [
+    {
+      detail: "зафиксированные решения",
+      label: "План",
+      tone: "neutral",
+      value: rewritePlan.readiness.approvedDecisionCount
+    },
+    {
+      detail: "есть pageId",
+      label: "Страницы",
+      tone: rewritePlan.readiness.existingPageTargetCount > 0 ? "good" : "warning",
+      value: rewritePlan.readiness.existingPageTargetCount
+    },
+    {
+      detail: "кандидаты для правок",
+      label: "Кандидаты",
+      tone: rewritePlan.readiness.rewriteCandidateCount > 0 ? "good" : "warning",
+      value: rewritePlan.readiness.rewriteCandidateCount
+    },
+    {
+      detail: "поля с текущим текстом",
+      label: "Поля",
+      tone: (rewriteDiff?.readiness.slotCount ?? 0) > 0 ? "good" : "neutral",
+      value: rewriteDiff?.readiness.slotCount ?? 0
+    },
+    {
+      detail: "можно отдавать модели",
+      label: "Готово модели",
+      tone: (rewriteDiff?.readiness.modelReadySlotCount ?? 0) > 0 ? "good" : "warning",
+      value: rewriteDiff?.readiness.modelReadySlotCount ?? 0
+    }
+  ];
+}
+
+function getRewriteFieldBars(rewritePlan: RewritePlanContract): SeoChartDatum[] {
+  const counts = rewritePlan.existingPageTargets
+    .flatMap((target) => target.keywordBindings)
+    .reduce<Record<RewritePlanContract["existingPageTargets"][number]["keywordBindings"][number]["field"], number>>(
+      (accumulator, binding) => {
+        accumulator[binding.field] = (accumulator[binding.field] ?? 0) + 1;
+        return accumulator;
+      },
+      {
+        body_section: 0,
+        h1: 0,
+        meta_description: 0,
+        title: 0
+      }
+    );
+
+  return (["title", "meta_description", "h1", "body_section"] as const).map((field) => ({
+    detail: "привязки полей",
+    label: getRewriteFieldLabel(field),
+    tone: field === "body_section" ? "neutral" : "good",
+    value: counts[field]
+  }));
+}
+
+function getMaterializationBars(materialization: MaterializationContract): SeoChartDatum[] {
+  return [
+    {
+      detail: "связано со страницами",
+      label: "Связано",
+      tone: "good",
+      value: materialization.readiness.linkedTargetCount
+    },
+    {
+      detail: "ожидает решения",
+      label: "Ожидает",
+      tone: "warning",
+      value: materialization.readiness.pendingTargetCount
+    },
+    {
+      detail: "плановые страницы",
+      label: "План",
+      tone: "neutral",
+      value: materialization.readiness.placeholderTargetCount
+    },
+    {
+      detail: "не пойдёт в правки",
+      label: "Отложено",
+      tone: "problem",
+      value: materialization.readiness.rejectedOrDeferredCount
+    }
+  ];
+}
+
+function getSeoStrategyStateLabel(state: SeoStrategyContract["state"]) {
+  const labels: Record<SeoStrategyContract["state"], string> = {
+    blocked: "заблокировано",
+    evidence_gap: "не хватает данных",
+    ready_for_review: "готово к review",
+    strategy_draft: "черновик стратегии"
+  };
+
+  return labels[state];
+}
+
+function getSeoStrategyStateClass(state: SeoStrategyContract["state"]) {
+  const classes: Record<SeoStrategyContract["state"], string> = {
+    blocked: "not_configured",
+    evidence_gap: "not_collected",
+    ready_for_review: "partial_ready",
+    strategy_draft: "partial_ready"
+  };
+
+  return classes[state];
+}
+
+function getStrategyTone(score: number): SeoChartTone {
+  if (score >= 75) {
+    return "good";
+  }
+
+  if (score >= 45) {
+    return "warning";
+  }
+
+  return "problem";
+}
+
+function getSeoStrategyConfidenceLabel(confidence: "high" | "low" | "medium") {
+  const labels = {
+    high: "высокая",
+    low: "низкая",
+    medium: "средняя"
+  };
+
+  return labels[confidence];
+}
+
+function getSeoStrategyPriorityLabel(priority: "high" | "low" | "medium") {
+  const labels = {
+    high: "высокий",
+    low: "низкий",
+    medium: "средний"
+  };
+
+  return labels[priority];
+}
+
+function getSeoMaturityPhaseLabel(phase: SeoStrategyContract["siteMaturity"]["phase"]) {
+  const labels: Record<SeoStrategyContract["siteMaturity"]["phase"], string> = {
+    authority_head_terms: "Authority / head terms",
+    bootstrap_indexing: "Bootstrap / indexing",
+    growth: "Growth",
+    traction: "Traction"
+  };
+
+  return labels[phase];
+}
+
+function getSeoPhaseStatusLabel(status: SeoStrategyContract["phasePlan"][number]["status"]) {
+  const labels: Record<SeoStrategyContract["phasePlan"][number]["status"], string> = {
+    current: "сейчас",
+    future: "следующая",
+    locked: "позже",
+    ready: "пройдено"
+  };
+
+  return labels[status];
+}
+
+function getSeoOpportunityActionLabel(action: SeoStrategyContract["opportunities"][number]["timing"]["action"]) {
+  const labels: Record<SeoStrategyContract["opportunities"][number]["timing"]["action"], string> = {
+    defer: "отложить",
+    do_now: "сейчас",
+    prepare: "готовить"
+  };
+
+  return labels[action];
+}
+
+function getSeoCompetitionTierLabel(tier: SeoStrategyContract["opportunities"][number]["competitionTier"]) {
+  const labels: Record<SeoStrategyContract["opportunities"][number]["competitionTier"], string> = {
+    head: "head",
+    long_tail: "long-tail",
+    mid: "mid",
+    unknown: "unknown"
+  };
+
+  return labels[tier];
+}
+
+function getSeoStrategyOwnerLabel(owner: SeoStrategyContract["missingEvidence"][number]["owner"]) {
+  const labels: Record<SeoStrategyContract["missingEvidence"][number]["owner"], string> = {
+    ai_layer: "AI layer",
+    external_service: "внешний сервис",
+    product_review: "product review"
+  };
+
+  return labels[owner];
+}
+
+function getSeoStrategyRiskLevelLabel(level: SeoStrategyContract["risks"][number]["level"]) {
+  const labels: Record<SeoStrategyContract["risks"][number]["level"], string> = {
+    critical: "critical",
+    high: "high",
+    medium: "medium"
+  };
+
+  return labels[level];
+}
+
+function getStrategySynthesisStateLabel(state: StrategySynthesisContract["state"]) {
+  const labels: Record<StrategySynthesisContract["state"], string> = {
+    not_ready: "не собрано",
+    ready: "готово"
+  };
+
+  return labels[state];
+}
+
+function getStrategySynthesisScenarioLabel(
+  scenario: StrategySynthesisContract["decisionOptions"][number]["scenario"]
+) {
+	  const labels: Record<StrategySynthesisContract["decisionOptions"][number]["scenario"], string> = {
+	    analytics_first: "сначала данные",
+	    bootstrap_runway: "bootstrap runway",
+	    core_growth: "рост ядра",
+    risk_reduction: "снижение риска",
+    serp_expansion: "SERP расширение"
+  };
+
+  return labels[scenario];
+}
+
+function getStrategySynthesisOwnerLabel(owner: StrategySynthesisContract["dataGaps"][number]["owner"]) {
+  const labels: Record<StrategySynthesisContract["dataGaps"][number]["owner"], string> = {
+    ai_layer: "AI layer",
+    external_service: "внешний сервис",
+    product_review: "product review"
+  };
+
+  return labels[owner];
+}
+
+function getStrategyQualityVerdictLabel(status: StrategyQualityReviewContract["verdict"]["status"]) {
+  const labels: Record<StrategyQualityReviewContract["verdict"]["status"], string> = {
+    approved: "готово к review",
+    blocked: "заблокировано",
+    needs_changes: "нужны правки"
+  };
+
+  return labels[status];
+}
+
+function getStrategyQualityVerdictClass(status: StrategyQualityReviewContract["verdict"]["status"]) {
+  const classes: Record<StrategyQualityReviewContract["verdict"]["status"], string> = {
+    approved: "partial_ready",
+    blocked: "not_ready",
+    needs_changes: "not_collected"
+  };
+
+  return classes[status];
+}
+
+function getStrategyQualityCheckLabel(status: StrategyQualityReviewContract["checks"][number]["status"]) {
+  const labels: Record<StrategyQualityReviewContract["checks"][number]["status"], string> = {
+    fail: "fail",
+    pass: "pass",
+    warning: "warning"
+  };
+
+  return labels[status];
+}
+
+function getStrategyQualityCheckClass(status: StrategyQualityReviewContract["checks"][number]["status"]) {
+  const classes: Record<StrategyQualityReviewContract["checks"][number]["status"], string> = {
+    fail: "not_configured",
+    pass: "collected",
+    warning: "ready_for_collection"
+  };
+
+  return classes[status];
+}
+
+function getStrategyQualityCategoryLabel(category: StrategyQualityReviewContract["checks"][number]["category"]) {
+  const labels: Record<StrategyQualityReviewContract["checks"][number]["category"], string> = {
+    business_drift: "business drift",
+    evidence_integrity: "evidence refs",
+    hallucination_guardrail: "hallucination",
+    phase_guardrail: "phase runway",
+    source_safety: "source safety",
+    ux_clarity: "UX clarity"
+  };
+
+  return labels[category];
+}
+
+function getYandexEvidenceStateLabel(state: YandexEvidenceContract["state"]) {
+  const labels: Record<YandexEvidenceContract["state"], string> = {
+    failed: "ошибка",
+    not_collected: "не собрано",
+    not_configured: "не настроено",
+    ready: "собрано"
+  };
+
+  return labels[state];
+}
+
+function getYandexEvidenceIntentLabel(intent: YandexEvidenceContract["phrases"][number]["interpretation"]["serpIntent"]) {
+  const labels: Record<YandexEvidenceContract["phrases"][number]["interpretation"]["serpIntent"], string> = {
+    commercial: "commercial",
+    informational: "info",
+    mixed: "mixed",
+    unknown: "unknown"
+  };
+
+  return labels[intent];
+}
+
+function getSerpTargetFitLabel(targetFit: SerpInterpretationContract["phraseInterpretations"][number]["targetFit"]) {
+  const labels: Record<SerpInterpretationContract["phraseInterpretations"][number]["targetFit"], string> = {
+    mismatch: "mismatch",
+    partial_fit: "частичный fit",
+    strong_fit: "сильный fit",
+    unknown: "неясно"
+  };
+
+  return labels[targetFit];
+}
+
+function getSerpRecommendedRoleLabel(role: SerpInterpretationContract["phraseInterpretations"][number]["recommendedRole"]) {
+  const labels: Record<SerpInterpretationContract["phraseInterpretations"][number]["recommendedRole"], string> = {
+    article_backlog: "контент",
+    core_landing: "ядро лендинга",
+    human_review: "ручная проверка",
+    support_section: "support-секция"
+  };
+
+  return labels[role];
+}
+
+function getYandexEvidenceSeasonalityLabel(
+  seasonality: YandexEvidenceContract["phrases"][number]["interpretation"]["seasonality"]
+) {
+  const labels: Record<YandexEvidenceContract["phrases"][number]["interpretation"]["seasonality"], string> = {
+    falling: "falling",
+    insufficient: "нет данных",
+    rising: "rising",
+    stable: "stable",
+    volatile: "volatile"
+  };
+
+  return labels[seasonality];
+}
+
+function getSeoStrategyReadinessBars(strategy: SeoStrategyContract): SeoChartDatum[] {
+  return [
+    {
+      detail: "strategy confidence",
+      label: "Score",
+      tone:
+        strategy.readiness.strategyConfidenceScore >= 75
+          ? "good"
+          : strategy.readiness.strategyConfidenceScore >= 45
+            ? "warning"
+            : "problem",
+      value: strategy.readiness.strategyConfidenceScore
+    },
+    {
+      detail: "approved keyword decisions",
+      label: "Решения",
+      tone: strategy.readiness.approvedKeywordCount > 0 ? "good" : "problem",
+      value: strategy.readiness.approvedKeywordCount
+    },
+    {
+      detail: "external evidence",
+      label: "Evidence",
+      tone: strategy.readiness.marketEvidenceCount > 0 ? "good" : "warning",
+      value: strategy.readiness.marketEvidenceCount
+    },
+    {
+      detail: "opportunity groups",
+      label: "Возможности",
+      tone: strategy.readiness.opportunityCount > 0 ? "good" : "warning",
+      value: strategy.readiness.opportunityCount
+    },
+    {
+      detail: "нужно закрыть",
+      label: "Gaps",
+      tone: strategy.readiness.evidenceGapCount > 0 ? "warning" : "good",
+      value: strategy.readiness.evidenceGapCount
+    }
+  ];
+}
+
+function getSeoStrategyDemandBars(strategy: SeoStrategyContract): SeoChartDatum[] {
+  return [
+    {
+      detail: "точные Wordstat seed",
+      label: "Exact",
+      tone: strategy.evidence.demand.exactSeedCount > 0 ? "good" : "warning",
+      value: strategy.evidence.demand.exactSeedCount
+    },
+    {
+      detail: "use/support candidates",
+      label: "Useful",
+      tone: strategy.evidence.demand.usefulCandidateCount > 0 ? "good" : "warning",
+      value: strategy.evidence.demand.usefulCandidateCount
+    },
+    {
+      detail: "требуют проверки",
+      label: "Risky",
+      tone: strategy.evidence.demand.riskyCandidateCount > 0 ? "warning" : "good",
+      value: strategy.evidence.demand.riskyCandidateCount
+    },
+    {
+      detail: "отфильтрованный шум",
+      label: "Trash",
+      tone: strategy.evidence.demand.rejectedNoiseCount > 0 ? "problem" : "neutral",
+      value: strategy.evidence.demand.rejectedNoiseCount
+    }
+  ];
+}
+
+function getSeoStrategyProviderBars(strategy: SeoStrategyContract): SeoChartDatum[] {
+  const connectedCount = strategy.evidence.providers.filter((provider) => provider.status === "connected").length;
+  const plannedCount = strategy.evidence.providers.filter((provider) => provider.status !== "connected").length;
+
+  return [
+    {
+      detail: "уже дают evidence",
+      label: "Connected",
+      tone: connectedCount > 0 ? "good" : "warning",
+      value: connectedCount
+    },
+    {
+      detail: "нужны для зрелой стратегии",
+      label: "Gaps",
+      tone: plannedCount > 0 ? "warning" : "good",
+      value: plannedCount
+    }
+  ];
+}
+
+function getStrategySynthesisMetrics(strategySynthesis: StrategySynthesisContract): SeoChartDatum[] {
+  return [
+    {
+      detail: "0-100, по evidence stack",
+      label: "Score",
+      tone: getStrategyTone(strategySynthesis.readiness.confidenceScore),
+      value: strategySynthesis.readiness.confidenceScore
+    },
+    {
+      detail: "варианты решения",
+      label: "Опции",
+      tone: strategySynthesis.readiness.decisionOptionCount > 0 ? "good" : "warning",
+      value: strategySynthesis.readiness.decisionOptionCount
+    },
+    {
+      detail: "чего не хватает",
+      label: "Gaps",
+      tone: strategySynthesis.readiness.dataGapCount > 0 ? "warning" : "good",
+      value: strategySynthesis.readiness.dataGapCount
+    },
+    {
+      detail: "риск-позиция",
+      label: "Риски",
+      tone: strategySynthesis.readiness.riskCount > 0 ? "warning" : "good",
+      value: strategySynthesis.readiness.riskCount
+    }
+  ];
+}
+
+function getStrategyQualityMetrics(review: StrategyQualityReviewContract): SeoChartDatum[] {
+  return [
+    {
+      detail: "quality gate score",
+      label: "Score",
+      tone: getStrategyTone(review.readiness.score),
+      value: review.readiness.score
+    },
+    {
+      detail: "checks passed",
+      label: "Pass",
+      tone: review.readiness.passedCount > 0 ? "good" : "warning",
+      value: review.readiness.passedCount
+    },
+    {
+      detail: "must fix",
+      label: "Blockers",
+      tone: review.readiness.blockerCount > 0 ? "problem" : "good",
+      value: review.readiness.blockerCount
+    },
+    {
+      detail: "needs attention",
+      label: "Warnings",
+      tone: review.readiness.warningCount > 0 ? "warning" : "good",
+      value: review.readiness.warningCount
+    }
+  ];
+}
+
+function SeoFunnelChart({ items, subtitle, title }: { items: SeoChartDatum[]; subtitle?: string; title: string }) {
+  const maxValue = Math.max(...items.map((item) => item.value), 1);
+
+  return (
+    <section className="seo-chart seo-funnel-chart" aria-label={title}>
+      <div className="seo-chart-heading">
+        <strong>{title}</strong>
+        {subtitle ? <small>{subtitle}</small> : null}
+      </div>
+      <div className="seo-funnel-rows">
+        {items.map((item) => {
+          const width = Math.max(7, getChartPercent(item.value, maxValue));
+
+          return (
+            <div className={`seo-funnel-row ${getChartToneClass(item.tone)}`} key={item.label}>
+              <div>
+                <span>{item.label}</span>
+                <strong>{formatCount(item.value)}</strong>
+              </div>
+              <div className="seo-funnel-track" aria-hidden="true">
+                <span style={{ "--seo-funnel-width": `${width}%` } as CSSProperties} />
+              </div>
+              {item.detail ? <small>{item.detail}</small> : null}
+            </div>
+          );
+        })}
+      </div>
+    </section>
+  );
+}
+
+function SeoBarChart({ items, subtitle, title }: { items: SeoChartDatum[]; subtitle?: string; title: string }) {
+  const maxValue = Math.max(...items.map((item) => item.value), 1);
+
+  return (
+    <section className="seo-chart seo-bar-chart" aria-label={title}>
+      <div className="seo-chart-heading">
+        <strong>{title}</strong>
+        {subtitle ? <small>{subtitle}</small> : null}
+      </div>
+      <div className="seo-bar-rows">
+        {items.map((item) => {
+          const width = Math.max(item.value > 0 ? 5 : 0, getChartPercent(item.value, maxValue));
+
+          return (
+            <div className={`seo-bar-row ${getChartToneClass(item.tone)}`} key={item.label}>
+              <div>
+                <span>{item.label}</span>
+                <strong>{formatCount(item.value)}</strong>
+              </div>
+              <div className="seo-bar-track" aria-hidden="true">
+                <span style={{ "--seo-bar-width": `${width}%` } as CSSProperties} />
+              </div>
+              {item.detail ? <small>{item.detail}</small> : null}
+            </div>
+          );
+        })}
+      </div>
+    </section>
+  );
+}
+
+function SeoShapeFunnelChart({ items, subtitle, title }: { items: SeoChartDatum[]; subtitle?: string; title: string }) {
+  const maxValue = Math.max(...items.map((item) => item.value), 0);
+  const data = [...items].sort((left, right) => right.value - left.value).map((item) => ({
+    color: getChartToneColor(item.tone),
+    displayValue: formatCount(item.value),
+    label: item.label,
+    value: maxValue > 0 ? item.value : 1
+  }));
+
+  return (
+    <section className="seo-chart seo-shape-funnel-chart seo-bklit-chart" aria-label={title}>
+      <div className="seo-chart-heading">
+        <strong>{title}</strong>
+        {subtitle ? <small>{subtitle}</small> : null}
+      </div>
+      <div className="seo-shape-funnel-body">
+        <div className="seo-bklit-native seo-bklit-funnel-native">
+          <BklitFunnelChart
+            data={data}
+            edges="curved"
+            formatValue={formatCount}
+            gap={6}
+            grid={{ bands: false, lines: true, lineColor: "rgba(24, 32, 29, 0.1)" }}
+            labelAlign="center"
+            labelLayout="grouped"
+            labelOrientation="vertical"
+            layers={3}
+            orientation="horizontal"
+            showPercentage={false}
+            showLabels={false}
+            showValues={false}
+          />
+        </div>
+        <div className="seo-chart-legend">
+          {items.map((item) => (
+            <div className={getChartToneClass(item.tone)} key={`${title}:${item.label}`}>
+              <span>
+                <i style={{ "--seo-chart-fill": getChartToneColor(item.tone) } as CSSProperties} />
+                {item.label}
+              </span>
+              <strong>{formatCount(item.value)}</strong>
+              {item.detail ? <small>{item.detail}</small> : null}
+            </div>
+          ))}
+        </div>
+      </div>
+    </section>
+  );
+}
+
+function SeoRingChart({
+  centerLabel,
+  centerValue,
+  items,
+  subtitle,
+  title
+}: {
+  centerLabel?: string;
+  centerValue?: number;
+  items: SeoChartDatum[];
+  subtitle?: string;
+  title: string;
+}) {
+  const total = items.reduce((sum, item) => sum + Math.max(0, item.value), 0);
+  const maxValue = Math.max(centerValue ?? total, total, 1);
+  const data = items.map((item) => ({
+    color: getChartToneColor(item.tone),
+    label: item.label,
+    maxValue,
+    value: item.value
+  }));
+
+  return (
+    <section className="seo-chart seo-ring-chart seo-bklit-chart" aria-label={title}>
+      <div className="seo-chart-heading">
+        <strong>{title}</strong>
+        {subtitle ? <small>{subtitle}</small> : null}
+      </div>
+      <div className="seo-ring-body">
+        <div className="seo-bklit-native seo-bklit-ring-native">
+          <BklitRingChart
+            baseInnerRadius={38}
+            data={data}
+            enterStaggerScale={0.7}
+            ringGap={5}
+            size={168}
+            strokeWidth={12}
+          >
+            {data.map((item, index) => (
+              <BklitRing animate={false} color={item.color} index={index} key={item.label} />
+            ))}
+            <BklitRingCenter defaultLabel={centerLabel ?? "total"} />
+          </BklitRingChart>
+        </div>
+        <div className="seo-chart-legend">
+          {items.map((item) => (
+            <div className={getChartToneClass(item.tone)} key={`${title}:${item.label}`}>
+              <span>
+                <i style={{ "--seo-chart-fill": getChartToneColor(item.tone) } as CSSProperties} />
+                {item.label}
+              </span>
+              <strong>{formatCount(item.value)}</strong>
+              {item.detail ? <small>{item.detail}</small> : null}
+            </div>
+          ))}
+        </div>
+      </div>
+    </section>
+  );
+}
+
+function SeoRadarChart({ items, subtitle, title }: { items: SeoChartDatum[]; subtitle?: string; title: string }) {
+  const metrics = items.map((item) => ({ key: item.label, label: item.label }));
+  const data = [
+    {
+      color: "#2f6b4f",
+      label: title,
+      values: items.reduce<Record<string, number>>((accumulator, item) => {
+        accumulator[item.label] = clampChartValue(item.value, 0, 100);
+        return accumulator;
+      }, {})
+    }
+  ];
+
+  return (
+    <section className="seo-chart seo-radar-chart seo-bklit-chart" aria-label={title}>
+      <div className="seo-chart-heading">
+        <strong>{title}</strong>
+        {subtitle ? <small>{subtitle}</small> : null}
+      </div>
+      <div className="seo-radar-body">
+        <div className="seo-bklit-native seo-bklit-radar-native">
+          <BklitRadarChart data={data} margin={42} metrics={metrics} size={190}>
+            <BklitRadarGrid />
+            <BklitRadarAxis />
+            <BklitRadarLabels fontSize={10} offset={14} />
+            <BklitRadarArea color="#2f6b4f" index={0} />
+          </BklitRadarChart>
+        </div>
+        <div className="seo-radar-legend">
+          {items.map((item) => (
+            <div className={getChartToneClass(item.tone)} key={`${title}:${item.label}`}>
+              <span>{item.label}</span>
+              <strong>{formatCount(item.value)}</strong>
+              {item.detail ? <small>{item.detail}</small> : null}
+            </div>
+          ))}
+        </div>
+      </div>
+    </section>
+  );
+}
+
+function SeoHeatmapChart({
+  emptyLabel,
+  matrix,
+  subtitle,
+  title
+}: {
+  emptyLabel: string;
+  matrix: SeoMatrixDatum;
+  subtitle?: string;
+  title: string;
+}) {
+  const maxValue = Math.max(
+    ...matrix.rows.flatMap((row) => matrix.columns.map((column) => row.cells[column.key] ?? 0)),
+    1
+  );
+  const heatmapData = matrix.columns.map((column, columnIndex) => ({
+    bin: columnIndex,
+    bins: matrix.rows.map((row, rowIndex) => ({
+      bin: rowIndex,
+      count: row.cells[column.key] ?? 0,
+      date: new Date(2026, 0, columnIndex + 1)
+    }))
+  }));
+  const heatmapColor = (count: number | null | undefined) => {
+    if (!count) return "rgba(24, 32, 29, 0.05)";
+    const opacity = 0.2 + getChartPercent(count, maxValue) * 0.006;
+    return `rgba(47, 107, 79, ${opacity})`;
+  };
+  const heatmapLevelColors = [
+    "rgba(24, 32, 29, 0.06)",
+    "rgba(47, 107, 79, 0.24)",
+    "rgba(47, 107, 79, 0.38)",
+    "rgba(47, 107, 79, 0.54)",
+    "rgba(47, 107, 79, 0.72)"
+  ] as const;
+
+  return (
+    <section className="seo-chart seo-heatmap-chart seo-bklit-chart" aria-label={title}>
+      <div className="seo-chart-heading">
+        <strong>{title}</strong>
+        {subtitle ? <small>{subtitle}</small> : null}
+      </div>
+      {matrix.rows.length > 0 ? (
+        <div className="seo-heatmap-native-layout">
+          <div className="seo-heatmap-native-columns">
+            <span />
+            {matrix.columns.map((column) => (
+              <span key={column.key}>{column.label}</span>
+            ))}
+          </div>
+          <div className="seo-heatmap-native-main">
+            <div className="seo-heatmap-native-rows">
+              {matrix.rows.map((row) => (
+                <strong key={row.key} title={row.label}>
+                  {row.label}
+                </strong>
+              ))}
+            </div>
+            <BklitHeatmapInteractionProvider>
+              <BklitHeatmapInteractionBoundary className="seo-bklit-native seo-bklit-heatmap-native">
+                <BklitHeatmapChart
+                  animate={false}
+                  aspectRatio={`${Math.max(matrix.columns.length, 1)} / ${Math.max(matrix.rows.length, 1)}`}
+                  binSize={0}
+                  className="seo-bklit-heatmap-chart"
+                  colorScale={heatmapColor}
+                  data={heatmapData}
+                  gap={6}
+                  layout="fluid"
+                  levelColors={heatmapLevelColors}
+                  margin={{ bottom: 0, left: 0, right: 0, top: 0 }}
+                >
+                  <BklitHeatmapCells cornerRadius={8} interactive />
+                </BklitHeatmapChart>
+              </BklitHeatmapInteractionBoundary>
+            </BklitHeatmapInteractionProvider>
+          </div>
+        </div>
+      ) : (
+        <p className="seo-chart-empty">{emptyLabel}</p>
+      )}
+    </section>
+  );
+}
+
+function SeoNormalizationReviewQueue({
+  emptyLabel,
+  seeds,
+  subtitle,
+  title
+}: {
+  emptyLabel: string;
+  seeds: SeoNormalizationSeedView[];
+  subtitle: string;
+  title: string;
+}) {
+  return (
+    <section className="market-normalization-review-queue">
+      <div>
+        <span>{title}</span>
+        <strong>{seeds.length}</strong>
+      </div>
+      <small>{subtitle}</small>
+      <div>
+        {seeds.length > 0 ? (
+          seeds.slice(0, 3).map((seed) => (
+            <p key={`${title}-${seed.id}`}>
+              <strong>{seed.phrase}</strong>
+              <small>
+                {getSeoMarketRoleLabel(seed.marketRole)} · {Math.round(seed.confidence * 100)}% ·{" "}
+                {getSeoSeedReviewShortLabel(seed)}
+              </small>
+            </p>
+          ))
+        ) : (
+          <p>
+            <strong>{emptyLabel}</strong>
+            <small>Очередь пустая.</small>
+          </p>
+        )}
+      </div>
+    </section>
+  );
+}
+
+function SeoKeywordCleaningLane({
+  emptyLabel,
+  items,
+  subtitle,
+  title
+}: {
+  emptyLabel: string;
+  items: KeywordCleaningItemView[];
+  subtitle: string;
+  title: string;
+}) {
+  return (
+    <section className="market-normalization-review-queue keyword-cleaning-lane">
+      <div>
+        <span>{title}</span>
+        <strong>{items.length}</strong>
+      </div>
+      <small>{subtitle}</small>
+      <div>
+        {items.length > 0 ? (
+          items.slice(0, 3).map((item) => (
+            <p key={`${title}-${item.id}`}>
+              <strong>{item.phrase}</strong>
+              <small>
+                {item.targetPath ?? "без страницы"} · {formatCount(item.frequency)} · {getKeywordCleaningSourceLabel(item.source)}
+              </small>
+            </p>
+          ))
+        ) : (
+          <p>
+            <strong>{emptyLabel}</strong>
+            <small>Очередь пустая.</small>
+          </p>
+        )}
+      </div>
+    </section>
+  );
+}
+
+function SeoScatterChart({
+  emptyLabel,
+  points,
+  subtitle,
+  title,
+  xLabel,
+  yLabel
+}: {
+  emptyLabel: string;
+  points: SeoScatterPoint[];
+  subtitle?: string;
+  title: string;
+  xLabel: string;
+  yLabel: string;
+}) {
+  const maxX = Math.max(...points.map((point) => point.x), 1);
+  const maxY = Math.max(...points.map((point) => point.y), 1);
+  const visiblePoints = points.slice(0, 24);
+  const chartData =
+    visiblePoints.length > 0
+      ? visiblePoints.map((point, index) => ({
+          date: new Date(2026, 0, index + 1),
+          demand: point.x,
+          priority: point.y
+        }))
+      : [];
+
+  return (
+    <section className="seo-chart seo-scatter-chart seo-bklit-chart" aria-label={title}>
+      <div className="seo-chart-heading">
+        <strong>{title}</strong>
+        {subtitle ? <small>{subtitle}</small> : null}
+      </div>
+      {visiblePoints.length > 0 ? (
+        <>
+          <div className="seo-scatter-frame seo-bklit-native seo-bklit-scatter-native">
+            <BklitScatterChart
+              aspectRatio="2 / 0.86"
+              data={chartData}
+              margin={{ bottom: 28, left: 28, right: 18, top: 18 }}
+              xDataKey="date"
+            >
+              <BklitGrid horizontal vertical={false} />
+              <BklitScatter dataKey="demand" fill="#536879" radius={5} />
+              <BklitScatter dataKey="priority" fill="#2f6b4f" radius={4} />
+              <BklitXAxis numTicks={Math.min(4, chartData.length)} />
+            </BklitScatterChart>
+            <span>{yLabel}</span>
+            <small>{xLabel}</small>
+          </div>
+          <div className="seo-scatter-legend">
+            {visiblePoints.slice(0, 5).map((point) => (
+              <span className={getChartToneClass(point.tone)} key={`${point.id}:legend`}>
+                {point.label}
+              </span>
+            ))}
+          </div>
+        </>
+      ) : (
+        <p className="seo-chart-empty">{emptyLabel}</p>
+      )}
+    </section>
+  );
+}
+
 function normalizeProjectName(value: string) {
   return value.trim().toLocaleLowerCase("ru-RU");
 }
@@ -392,6 +2273,103 @@ function getProjectScanStatusMessage(scan: ProjectScanSummary) {
   return `Скан запускался: ${getScanStatusLabel(scan.status)} · страниц: ${scan.counts.pages}, ассетов: ${scan.counts.assets}${completedAt}.`;
 }
 
+function isScanReadyForFlow(scan: ProjectScanSummary | null | undefined) {
+  return Boolean(scan && scan.status === "done" && scan.pages.length > 0);
+}
+
+function getPipelineStageAccess(
+  stageIndex: number,
+  input: {
+    contextReview: SeoContextReviewRun | null;
+    hasProject: boolean;
+    keywordMap: KeywordMapContract | null;
+    marketEnrichment: MarketEnrichmentContract | null;
+    scan: ProjectScanSummary | null | undefined;
+    semanticAnalysis: SemanticAnalysisRun | null;
+    seoStrategy: SeoStrategyContract | null;
+    strategyQualityReview: StrategyQualityReviewContract | null;
+    strategySynthesis: StrategySynthesisContract | null;
+  }
+) {
+  const scanReady = isScanReadyForFlow(input.scan);
+  const contextReady = Boolean(input.semanticAnalysis && input.contextReview);
+  const marketReady = Boolean(input.marketEnrichment && input.marketEnrichment.state !== "not_ready");
+  const keywordReady = Boolean(input.keywordMap && input.keywordMap.readiness.mappedItemCount > 0);
+  const strategyReady = Boolean(input.seoStrategy && input.seoStrategy.state !== "blocked");
+  const synthesisReady = input.strategySynthesis?.state === "ready";
+  const qualityReady = input.strategyQualityReview?.state === "ready";
+
+  if (stageIndex === 0) {
+    return { reason: "Импортируй сайт или выбери уже созданный проект.", status: "open", unlocked: true };
+  }
+
+  if (!input.hasProject) {
+    return { reason: "Сначала выбери проект на экране источника.", status: "locked", unlocked: false };
+  }
+
+  if (stageIndex === 1) {
+    return {
+      reason: scanReady ? "Проект инициализирован, scope можно подтверждать." : "Инициализируем проект: сканируем страницы, ассеты и SEO-разметку.",
+      status: scanReady ? "ready" : "setup",
+      unlocked: true
+    };
+  }
+
+  if (stageIndex === 2) {
+    return {
+      reason: scanReady ? "Рабочая зона доступна по выбранным страницам." : "Сначала нужен успешный скан и scope проекта.",
+      status: scanReady ? "ready" : "locked",
+      unlocked: scanReady
+    };
+  }
+
+  if (stageIndex === 3) {
+    return {
+      reason: scanReady ? "Можно запускать анализ контекста сайта." : "Контекст недоступен без файлов и базового аудита.",
+      status: scanReady ? "ready" : "locked",
+      unlocked: scanReady
+    };
+  }
+
+  if (stageIndex === 4) {
+    return {
+      reason: contextReady ? "Контекст собран, можно проверять внешний спрос." : "Сначала запусти анализ контекста и Context Review.",
+      status: contextReady ? "ready" : "locked",
+      unlocked: contextReady
+    };
+  }
+
+  if (stageIndex === 5) {
+    return {
+      reason: marketReady && keywordReady ? "Есть спрос и карта фраз, можно смотреть SEO-план." : "Сначала нужен рыночный спрос и keyword map.",
+      status: marketReady && keywordReady ? "ready" : "locked",
+      unlocked: marketReady && keywordReady
+    };
+  }
+
+  if (stageIndex === 6) {
+    return {
+      reason: strategyReady ? "Стратегия доступна: можно выбирать фазу старта." : "Сначала нужен SEO-план и evidence base.",
+      status: strategyReady ? "ready" : "locked",
+      unlocked: strategyReady
+    };
+  }
+
+  if (stageIndex === 7) {
+    return {
+      reason: synthesisReady ? "Strategy synthesis собран, можно проверять качество." : "Сначала собери strategy synthesis.",
+      status: synthesisReady ? "ready" : "locked",
+      unlocked: synthesisReady
+    };
+  }
+
+  return {
+    reason: qualityReady ? "Quality gate пройден; apply всё ещё остаётся будущим контролируемым контуром." : "Применение заблокировано до quality review.",
+    status: qualityReady ? "future" : "locked",
+    unlocked: qualityReady
+  };
+}
+
 function getAuditIssueCounts(issues: AuditIssue[]) {
   return issues.reduce(
     (counts, issue) => {
@@ -464,6 +2442,27 @@ function getSemanticQualityLabel(level: SemanticAnalysisRun["qualitySignals"][nu
   return labels[level];
 }
 
+function getProjectOntologySourceLabel(source: NonNullable<SemanticAnalysisRun["projectOntology"]>["source"]) {
+  const labels = {
+    extracted: "из сайта",
+    generic_fallback: "базовая",
+    seed_fixture: "seed fixture"
+  };
+
+  return labels[source];
+}
+
+function getProjectOntologyApprovalLabel(status: ProjectOntologyApprovalStatus) {
+  const labels = {
+    approved: "утверждена",
+    draft: "черновик",
+    needs_review: "нужна проверка",
+    rejected: "отклонена"
+  };
+
+  return labels[status];
+}
+
 function getSemanticVerdictConfidenceLabel(
   confidence: NonNullable<SemanticAnalysisRun["analysisVerdict"]>["confidence"]
 ) {
@@ -540,9 +2539,9 @@ type SemanticBriefQuality = NonNullable<SemanticBrief["qualityContract"]>;
 
 function getBriefQualityLevelLabel(level: SemanticBriefQuality["level"]) {
   const labels = {
-    blocked: "blocked",
-    needs_work: "needs work",
-    ready: "ready"
+    blocked: "заблокировано",
+    needs_work: "нужно доработать",
+    ready: "готово"
   };
 
   return labels[level];
@@ -550,9 +2549,9 @@ function getBriefQualityLevelLabel(level: SemanticBriefQuality["level"]) {
 
 function getBriefQualityCheckLabel(status: SemanticBriefQuality["checks"][number]["status"]) {
   const labels = {
-    fail: "fail",
-    pass: "pass",
-    warn: "warn"
+    fail: "ошибка",
+    pass: "ок",
+    warn: "риск"
   };
 
   return labels[status];
@@ -571,10 +2570,10 @@ function getMarketStateLabel(state: MarketEnrichmentContract["state"]) {
 
 function getMarketProviderStatusLabel(status: MarketEnrichmentContract["providers"][number]["status"]) {
   const labels = {
-    connected: "connected",
-    disabled: "disabled",
-    not_configured: "not configured",
-    not_implemented: "not implemented"
+    connected: "подключено",
+    disabled: "выключено",
+    not_configured: "не настроено",
+    not_implemented: "планируется"
   };
 
   return labels[status];
@@ -582,14 +2581,163 @@ function getMarketProviderStatusLabel(status: MarketEnrichmentContract["provider
 
 function getMarketEvidenceStatusLabel(status: MarketEnrichmentContract["seedQueue"][number]["evidenceStatus"]) {
   const labels = {
-    collection_failed: "failed",
-    collected: "collected",
-    collected_no_signal: "no signal",
-    collected_related_only: "related only",
-    deterministic_only: "deterministic",
-    not_collected: "not collected",
+    collection_failed: "ошибка сбора",
+    collected: "собрано",
+    collected_no_signal: "нет сигнала",
+    collected_related_only: "только смежное",
+    deterministic_only: "из контекста",
+    not_collected: "не собрано",
+    not_configured: "не настроено",
+    ready_for_collection: "готово к сбору"
+  };
+
+  return labels[status];
+}
+
+function getSeoIntentTypeLabel(intentType: SeoNormalizationContract["intentGroups"][number]["intentType"]) {
+  const labels = {
+    commercial: "коммерция",
+    deployment_security: "развёртывание",
+    enterprise: "enterprise",
+    informational: "инфо",
+    integration: "интеграции",
+    problem: "проблема",
+    product: "продукт",
+    support: "поддержка"
+  };
+
+  return labels[intentType];
+}
+
+function getSeoMarketRoleLabel(role: SeoNormalizationContract["seedStrategy"][number]["marketRole"]) {
+  const labels = {
+    commercial: "коммерция",
+    core: "ядро",
+    exclude: "отсечь",
+    integration: "интеграции",
+    problem: "проблема",
+    support: "поддержка"
+  };
+
+  return labels[role];
+}
+
+function getKeywordMapStateLabel(state: KeywordMapContract["state"]) {
+  const labels = {
+    blocked: "заблокировано",
+    draft: "черновик"
+  };
+
+  return labels[state];
+}
+
+function getKeywordMapRoleLabel(role: KeywordMapContract["items"][number]["role"] | string) {
+  const labels = {
+    primary: "главный",
+    secondary: "доп.",
+    support: "поддержка",
+    validate: "проверить"
+  };
+
+  return labels[role as keyof typeof labels] ?? role;
+}
+
+function getRewritePlanStateLabel(state: RewritePlanContract["state"]) {
+  const labels = {
+    blocked: "заблокировано",
+    materialization_required: "нужны посадочные",
+    partial_ready: "частично готово",
+    ready_for_diff: "готово к правкам"
+  };
+
+  return labels[state];
+}
+
+function getRewriteFieldLabel(field: RewritePlanContract["existingPageTargets"][number]["keywordBindings"][number]["field"]) {
+  const labels = {
+    body_section: "body",
+    h1: "H1",
+    meta_description: "description",
+    title: "title"
+  };
+
+  return labels[field];
+}
+
+function getMaterializationStateLabel(state: MaterializationContract["state"]) {
+  const labels = {
+    blocked: "заблокировано",
+    complete: "готово",
+    partial: "частично готово",
+    pending: "ожидает решений"
+  };
+
+  return labels[state];
+}
+
+function getMaterializationStatusLabel(status: MaterializationContract["targets"][number]["status"]) {
+  const labels = {
+    awaiting_source: "source approved",
+    can_link_existing: "можно связать",
+    deferred: "отложено",
+    linked_existing: "связано",
+    needs_materialization: "нужна страница",
+    planned_placeholder: "плановая",
+    rejected: "отклонено"
+  };
+
+  return labels[status];
+}
+
+function getRewriteDiffStateLabel(state: RewriteDiffContract["state"]) {
+  const labels = {
+    blocked: "заблокировано",
+    materialization_required: "нужны страницы",
+    partial_ready: "частично готово",
+    ready_for_model_review: "готово"
+  };
+
+  return labels[state];
+}
+
+function getRewriteDiffSlotStatusLabel(status: RewriteDiffContract["targets"][number]["slots"][number]["status"]) {
+  const labels = {
+    ready_for_model_review: "готово",
+    source_pending: "ждёт источник"
+  };
+
+  return labels[status];
+}
+
+function getModelTaskTypeLabel(taskType: SeoModelTaskType) {
+  const labels = {
+    "seo.context_review": "Context Review",
+    "seo.keyword_cleaning": "Keyword Cleaning",
+    "seo.normalization": "Normalization",
+    "seo.serp_interpretation": "SERP Interpretation",
+    "seo.strategy_quality_review": "Strategy Quality",
+    "seo.strategy_synthesis": "Strategy Synthesis"
+  };
+
+  return labels[taskType];
+}
+
+function getModelTaskRunStatusLabel(status: SeoModelTaskRun["status"]) {
+  const labels = {
+    contract_ready: "contract ready",
+    provider_not_configured: "provider не подключён",
+    task_not_found: "task не найден",
+    validation_failed: "ошибка контракта"
+  };
+
+  return labels[status];
+}
+
+function getModelProviderStatusLabel(status: SeoModelProviderStatusContract["catalog"]["providers"][number]["status"]) {
+  const labels = {
+    active: "active",
     not_configured: "not configured",
-    ready_for_collection: "ready"
+    planned: "planned"
   };
 
   return labels[status];
@@ -608,7 +2756,7 @@ function getExternalServiceStatusLabel(status: ExternalService["status"]) {
 
 function getExternalServiceShortName(serviceId: ExternalService["id"]) {
   const labels = {
-    yandex_cloud: "Yandex Cloud credentials",
+    yandex_cloud: "Yandex AI Studio / Cloud API key",
     yandex_metrica: "Yandex Metrica",
     yandex_search_serp: "Yandex SERP",
     yandex_webmaster: "Yandex Webmaster",
@@ -620,10 +2768,10 @@ function getExternalServiceShortName(serviceId: ExternalService["id"]) {
 
 function getExternalMissingFieldLabel(fieldId: string) {
   const labels: Record<string, string> = {
-    apiKey: "API key",
+    apiKey: "Yandex AI Studio API key",
     folderId: "folderId",
     iamToken: "IAM token",
-    yandex_cloud: "Yandex Cloud credentials"
+    yandex_cloud: "Yandex AI Studio / Cloud API key"
   };
 
   return labels[fieldId] ?? fieldId;
@@ -1479,7 +3627,23 @@ export function App() {
   const [activeProjectId, setActiveProjectId] = useState<string | null>(null);
   const [scanSummaries, setScanSummaries] = useState<Record<string, ProjectScanSummary | null>>({});
   const [semanticAnalyses, setSemanticAnalyses] = useState<Record<string, SemanticAnalysisRun | null>>({});
+  const [contextReviews, setContextReviews] = useState<Record<string, SeoContextReviewRun | null>>({});
+  const [projectOntologies, setProjectOntologies] = useState<Record<string, ProjectOntologyVersion | null>>({});
   const [marketEnrichments, setMarketEnrichments] = useState<Record<string, MarketEnrichmentContract | null>>({});
+  const [keywordCleanings, setKeywordCleanings] = useState<Record<string, KeywordCleaningContract | null>>({});
+  const [keywordMaps, setKeywordMaps] = useState<Record<string, KeywordMapContract | null>>({});
+  const [seoStrategies, setSeoStrategies] = useState<Record<string, SeoStrategyContract | null>>({});
+  const [yandexEvidences, setYandexEvidences] = useState<Record<string, YandexEvidenceContract | null>>({});
+  const [serpInterpretations, setSerpInterpretations] = useState<Record<string, SerpInterpretationContract | null>>({});
+  const [strategySyntheses, setStrategySyntheses] = useState<Record<string, StrategySynthesisContract | null>>({});
+  const [strategyQualityReviews, setStrategyQualityReviews] = useState<Record<string, StrategyQualityReviewContract | null>>({});
+  const [selectedStrategyPhaseIds, setSelectedStrategyPhaseIds] = useState<
+    Record<string, SeoStrategyContract["siteMaturity"]["phase"]>
+  >({});
+  const [rewritePlans, setRewritePlans] = useState<Record<string, RewritePlanContract | null>>({});
+  const [materializationContracts, setMaterializationContracts] = useState<Record<string, MaterializationContract | null>>({});
+  const [rewriteDiffContracts, setRewriteDiffContracts] = useState<Record<string, RewriteDiffContract | null>>({});
+  const [modelProviderStatuses, setModelProviderStatuses] = useState<Record<string, SeoModelProviderStatusContract | null>>({});
   const [activeSemanticClusterIds, setActiveSemanticClusterIds] = useState<Record<string, string>>({});
   const [projectsError, setProjectsError] = useState<string | null>(null);
   const [projectsLoading, setProjectsLoading] = useState(true);
@@ -1489,13 +3653,28 @@ export function App() {
   const [isSubmitting, setIsSubmitting] = useState(false);
   const [isFolderDragActive, setIsFolderDragActive] = useState(false);
   const [folderPickerMessage, setFolderPickerMessage] = useState<string | null>(null);
+  const [pendingProjectName, setPendingProjectName] = useState("");
+  const [isProjectNameModalOpen, setIsProjectNameModalOpen] = useState(false);
+  const [isProjectMenuOpen, setIsProjectMenuOpen] = useState(false);
+  const [isWorkPanelOpen, setIsWorkPanelOpen] = useState(false);
+  const [isWorkPanelFullscreen, setIsWorkPanelFullscreen] = useState(false);
   const [editingProjectId, setEditingProjectId] = useState<string | null>(null);
   const [editingProjectName, setEditingProjectName] = useState("");
   const [busyProjectId, setBusyProjectId] = useState<string | null>(null);
   const [pendingDeleteProjectId, setPendingDeleteProjectId] = useState<string | null>(null);
   const [scanningProjectId, setScanningProjectId] = useState<string | null>(null);
   const [analyzingProjectId, setAnalyzingProjectId] = useState<string | null>(null);
+  const [reviewingContextProjectId, setReviewingContextProjectId] = useState<string | null>(null);
+  const [approvingOntologyKey, setApprovingOntologyKey] = useState<string | null>(null);
+  const [confirmingOntologyKey, setConfirmingOntologyKey] = useState<string | null>(null);
   const [enrichingMarketProjectId, setEnrichingMarketProjectId] = useState<string | null>(null);
+  const [collectingYandexEvidenceProjectId, setCollectingYandexEvidenceProjectId] = useState<string | null>(null);
+  const [interpretingSerpProjectId, setInterpretingSerpProjectId] = useState<string | null>(null);
+  const [synthesizingStrategyProjectId, setSynthesizingStrategyProjectId] = useState<string | null>(null);
+  const [reviewingStrategyQualityProjectId, setReviewingStrategyQualityProjectId] = useState<string | null>(null);
+  const [persistingKeywordMapProjectId, setPersistingKeywordMapProjectId] = useState<string | null>(null);
+  const [materializingTargetKey, setMaterializingTargetKey] = useState<string | null>(null);
+  const [runningModelTaskKey, setRunningModelTaskKey] = useState<string | null>(null);
   const [exportingSemanticKey, setExportingSemanticKey] = useState<string | null>(null);
   const [selectingPagesProjectId, setSelectingPagesProjectId] = useState<string | null>(null);
   const [auditIssueLimits, setAuditIssueLimits] = useState<Record<string, number>>({});
@@ -1520,6 +3699,8 @@ export function App() {
   const [externalServiceDrafts, setExternalServiceDrafts] = useState<Record<string, ExternalServiceDraft>>({});
   const [externalServicesLoading, setExternalServicesLoading] = useState(false);
   const [savingExternalServiceId, setSavingExternalServiceId] = useState<string | null>(null);
+  const [probingExternalServiceId, setProbingExternalServiceId] = useState<string | null>(null);
+  const [yandexAiStudioProbe, setYandexAiStudioProbe] = useState<YandexAiStudioProbe | null>(null);
   const [externalServicesError, setExternalServicesError] = useState<string | null>(null);
   const [externalServicesMessage, setExternalServicesMessage] = useState<string | null>(null);
 
@@ -1553,6 +3734,36 @@ export function App() {
     setSemanticAnalyses(Object.fromEntries(analysisEntries));
   }
 
+  async function loadContextReviews(projectList: ProjectSummary[]) {
+    const contextReviewEntries = await Promise.all(
+      projectList.map(async (project) => {
+        try {
+          const result = await fetchLatestSeoContextReview(project.id);
+          return [project.id, result.contextReview] as const;
+        } catch {
+          return [project.id, null] as const;
+        }
+      })
+    );
+
+    setContextReviews(Object.fromEntries(contextReviewEntries));
+  }
+
+  async function loadProjectOntologies(projectList: ProjectSummary[]) {
+    const ontologyEntries = await Promise.all(
+      projectList.map(async (project) => {
+        try {
+          const result = await fetchLatestProjectOntology(project.id);
+          return [project.id, result.ontology] as const;
+        } catch {
+          return [project.id, null] as const;
+        }
+      })
+    );
+
+    setProjectOntologies(Object.fromEntries(ontologyEntries));
+  }
+
   async function loadMarketEnrichments(projectList: ProjectSummary[]) {
     const marketEntries = await Promise.all(
       projectList.map(async (project) => {
@@ -1568,6 +3779,171 @@ export function App() {
     setMarketEnrichments(Object.fromEntries(marketEntries));
   }
 
+  async function loadKeywordCleanings(projectList: ProjectSummary[]) {
+    const keywordCleaningEntries = await Promise.all(
+      projectList.map(async (project) => {
+        try {
+          const result = await fetchLatestKeywordCleaning(project.id);
+          return [project.id, result.keywordCleaning] as const;
+        } catch {
+          return [project.id, null] as const;
+        }
+      })
+    );
+
+    setKeywordCleanings(Object.fromEntries(keywordCleaningEntries));
+  }
+
+  async function loadKeywordMaps(projectList: ProjectSummary[]) {
+    const keywordMapEntries = await Promise.all(
+      projectList.map(async (project) => {
+        try {
+          const result = await fetchLatestKeywordMap(project.id);
+          return [project.id, result.keywordMap] as const;
+        } catch {
+          return [project.id, null] as const;
+        }
+      })
+    );
+
+    setKeywordMaps(Object.fromEntries(keywordMapEntries));
+  }
+
+  async function loadSeoStrategies(projectList: ProjectSummary[]) {
+    const strategyEntries = await Promise.all(
+      projectList.map(async (project) => {
+        try {
+          const result = await fetchLatestSeoStrategy(project.id);
+          return [project.id, result.strategy] as const;
+        } catch {
+          return [project.id, null] as const;
+        }
+      })
+    );
+
+    setSeoStrategies(Object.fromEntries(strategyEntries));
+  }
+
+  async function loadYandexEvidences(projectList: ProjectSummary[]) {
+    const evidenceEntries = await Promise.all(
+      projectList.map(async (project) => {
+        try {
+          const result = await fetchLatestYandexEvidence(project.id);
+          return [project.id, result.yandexEvidence] as const;
+        } catch {
+          return [project.id, null] as const;
+        }
+      })
+    );
+
+    setYandexEvidences(Object.fromEntries(evidenceEntries));
+  }
+
+  async function loadSerpInterpretations(projectList: ProjectSummary[]) {
+    const interpretationEntries = await Promise.all(
+      projectList.map(async (project) => {
+        try {
+          const result = await fetchLatestSerpInterpretation(project.id);
+          return [project.id, result.serpInterpretation] as const;
+        } catch {
+          return [project.id, null] as const;
+        }
+      })
+    );
+
+    setSerpInterpretations(Object.fromEntries(interpretationEntries));
+  }
+
+  async function loadStrategySyntheses(projectList: ProjectSummary[]) {
+    const synthesisEntries = await Promise.all(
+      projectList.map(async (project) => {
+        try {
+          const result = await fetchLatestStrategySynthesis(project.id);
+          return [project.id, result.strategySynthesis] as const;
+        } catch {
+          return [project.id, null] as const;
+        }
+      })
+    );
+
+    setStrategySyntheses(Object.fromEntries(synthesisEntries));
+  }
+
+  async function loadStrategyQualityReviews(projectList: ProjectSummary[]) {
+    const reviewEntries = await Promise.all(
+      projectList.map(async (project) => {
+        try {
+          const result = await fetchLatestStrategyQualityReview(project.id);
+          return [project.id, result.strategyQualityReview] as const;
+        } catch {
+          return [project.id, null] as const;
+        }
+      })
+    );
+
+    setStrategyQualityReviews(Object.fromEntries(reviewEntries));
+  }
+
+  async function loadRewritePlans(projectList: ProjectSummary[]) {
+    const rewritePlanEntries = await Promise.all(
+      projectList.map(async (project) => {
+        try {
+          const result = await fetchLatestRewritePlan(project.id);
+          return [project.id, result.rewritePlan] as const;
+        } catch {
+          return [project.id, null] as const;
+        }
+      })
+    );
+
+    setRewritePlans(Object.fromEntries(rewritePlanEntries));
+  }
+
+  async function loadMaterializationContracts(projectList: ProjectSummary[]) {
+    const materializationEntries = await Promise.all(
+      projectList.map(async (project) => {
+        try {
+          const result = await fetchLatestMaterialization(project.id);
+          return [project.id, result.materialization] as const;
+        } catch {
+          return [project.id, null] as const;
+        }
+      })
+    );
+
+    setMaterializationContracts(Object.fromEntries(materializationEntries));
+  }
+
+  async function loadRewriteDiffContracts(projectList: ProjectSummary[]) {
+    const rewriteDiffEntries = await Promise.all(
+      projectList.map(async (project) => {
+        try {
+          const result = await fetchLatestRewriteDiff(project.id);
+          return [project.id, result.rewriteDiff] as const;
+        } catch {
+          return [project.id, null] as const;
+        }
+      })
+    );
+
+    setRewriteDiffContracts(Object.fromEntries(rewriteDiffEntries));
+  }
+
+  async function loadModelProviderStatuses(projectList: ProjectSummary[]) {
+    const statusEntries = await Promise.all(
+      projectList.map(async (project) => {
+        try {
+          const result = await fetchModelProviderStatus(project.id);
+          return [project.id, result.modelProvider] as const;
+        } catch {
+          return [project.id, null] as const;
+        }
+      })
+    );
+
+    setModelProviderStatuses(Object.fromEntries(statusEntries));
+  }
+
   async function loadExternalServices() {
     setExternalServicesLoading(true);
     setExternalServicesError(null);
@@ -1587,6 +3963,7 @@ export function App() {
 
   function openExternalServicesModal() {
     setIsExternalServicesOpen(true);
+    setYandexAiStudioProbe(null);
     void loadExternalServices();
   }
 
@@ -1644,7 +4021,15 @@ export function App() {
       setExternalServicesMessage(`${result.service.label}: настройки сохранены.`);
 
       if (service.id === "yandex_wordstat") {
-        await loadMarketEnrichments(projects);
+        await Promise.all([
+          loadMarketEnrichments(projects),
+          loadKeywordCleanings(projects),
+          loadKeywordMaps(projects),
+          loadSeoStrategies(projects),
+          loadRewritePlans(projects),
+          loadMaterializationContracts(projects),
+          loadRewriteDiffContracts(projects)
+        ]);
       }
     } catch (error: unknown) {
       setExternalServicesError(getErrorMessage(error, "Не удалось сохранить внешний сервис."));
@@ -1653,6 +4038,25 @@ export function App() {
     }
   }
 
+  async function handleProbeYandexAiStudioCredential() {
+    setProbingExternalServiceId("yandex_cloud");
+    setExternalServicesError(null);
+    setExternalServicesMessage(null);
+
+    try {
+      const result = await probeYandexAiStudioCredential();
+
+      setYandexAiStudioProbe(result.probe);
+      setExternalServicesMessage(
+        `Yandex AI Studio: ${result.probe.capabilities.filter((capability) => capability.ok).length}/${result.probe.capabilities.length} checks ok.`
+      );
+    } catch (error: unknown) {
+      setExternalServicesError(getErrorMessage(error, "Не удалось проверить Yandex AI Studio."));
+    } finally {
+      setProbingExternalServiceId(null);
+    }
+  }
+
   async function loadProjects() {
     setProjectsLoading(true);
     setProjectsError(null);
@@ -1660,7 +4064,24 @@ export function App() {
     try {
       const result = await fetchProjects();
       setProjects(result.projects);
-      await Promise.all([loadScanSummaries(result.projects), loadSemanticAnalyses(result.projects), loadMarketEnrichments(result.projects)]);
+      await Promise.all([
+        loadScanSummaries(result.projects),
+        loadSemanticAnalyses(result.projects),
+        loadContextReviews(result.projects),
+        loadProjectOntologies(result.projects),
+        loadMarketEnrichments(result.projects),
+        loadKeywordCleanings(result.projects),
+        loadKeywordMaps(result.projects),
+        loadYandexEvidences(result.projects),
+        loadSerpInterpretations(result.projects),
+        loadSeoStrategies(result.projects),
+        loadStrategySyntheses(result.projects),
+        loadStrategyQualityReviews(result.projects),
+        loadRewritePlans(result.projects),
+        loadMaterializationContracts(result.projects),
+        loadRewriteDiffContracts(result.projects),
+        loadModelProviderStatuses(result.projects)
+      ]);
     } catch (error: unknown) {
       setProjectsError(getErrorMessage(error, "Не удалось загрузить проекты."));
     } finally {
@@ -1668,6 +4089,13 @@ export function App() {
     }
   }
 
+  function invalidateStrategyQualityReview(projectId: string) {
+    setStrategyQualityReviews((currentReviews) => ({
+      ...currentReviews,
+      [projectId]: null
+    }));
+  }
+
   useEffect(() => {
     let cancelled = false;
 
@@ -1891,11 +4319,9 @@ export function App() {
       return;
     }
 
-    if (activeProjectId && projects.some((project) => project.id === activeProjectId)) {
-      return;
+    if (activeProjectId && !projects.some((project) => project.id === activeProjectId)) {
+      setActiveProjectId(null);
     }
-
-    setActiveProjectId(projects[0].id);
   }, [activeProjectId, projects]);
 
   useEffect(() => {
@@ -1953,6 +4379,8 @@ export function App() {
     const stats = getFolderStats(folder);
 
     setPickedFolder(folder);
+    setPendingProjectName(folder.rootName);
+    setIsProjectNameModalOpen(true);
     setFolderPickerMessage(
       `Выбрана папка «${folder.rootName}»: ${stats.fileCount} файлов, ${formatBytes(stats.totalBytes)}.`
     );
@@ -1962,6 +4390,8 @@ export function App() {
     setPickedFolder(null);
     setFolderPickerMessage(null);
     setCreateError(null);
+    setPendingProjectName("");
+    setIsProjectNameModalOpen(false);
 
     if (folderInputRef.current) {
       folderInputRef.current.value = "";
@@ -2017,12 +4447,23 @@ export function App() {
     }
   }
 
-  async function handleCreateProject(event: FormEvent<HTMLFormElement>) {
-    event.preventDefault();
+  async function createProjectFromFolder(folder: PickedFolder, projectName: string) {
     setCreateError(null);
     setCreateMessage(null);
 
-    if (!pickedFolder) {
+    const normalizedProjectName = projectName.trim();
+
+    if (!normalizedProjectName) {
+      setCreateError("Название проекта не должно быть пустым.");
+      return;
+    }
+
+    if (hasProjectNameConflict(normalizedProjectName)) {
+      setCreateError(`Проект с названием «${normalizedProjectName}» уже есть.`);
+      return;
+    }
+
+    if (!folder) {
       setCreateError("Выбери папку сайта или перетащи её в область импорта.");
       return;
     }
@@ -2031,13 +4472,17 @@ export function App() {
 
     try {
       const result = await importBrowserFolder({
-        name: pickedFolder.rootName,
-        rootName: pickedFolder.rootName,
-        files: await serializeFolderFiles(pickedFolder)
+        name: normalizedProjectName,
+        rootName: folder.rootName,
+        files: await serializeFolderFiles(folder)
       });
 
       setPickedFolder(null);
       setFolderPickerMessage(null);
+      setPendingProjectName("");
+      setIsProjectNameModalOpen(false);
+      setIsProjectMenuOpen(false);
+      setIsWorkPanelFullscreen(false);
       setActiveProjectId(result.project.id);
       setProjects((currentProjects) => [
         result.project,
@@ -2047,10 +4492,30 @@ export function App() {
         ...currentSummaries,
         [result.project.id]: null
       }));
+      setProjectOntologies((currentOntologies) => ({
+        ...currentOntologies,
+        [result.project.id]: null
+      }));
       setMarketEnrichments((currentEnrichments) => ({
         ...currentEnrichments,
         [result.project.id]: null
       }));
+      setKeywordMaps((currentKeywordMaps) => ({
+        ...currentKeywordMaps,
+        [result.project.id]: null
+      }));
+      setRewritePlans((currentRewritePlans) => ({
+        ...currentRewritePlans,
+        [result.project.id]: null
+      }));
+      setMaterializationContracts((currentContracts) => ({
+        ...currentContracts,
+        [result.project.id]: null
+      }));
+      setRewriteDiffContracts((currentContracts) => ({
+        ...currentContracts,
+        [result.project.id]: null
+      }));
       setCreateMessage(
         `Проект «${result.project.name}» создан, папка импортирована в хранилище.\nПервичный скан запущен автоматически.`
       );
@@ -2063,6 +4528,17 @@ export function App() {
     }
   }
 
+  async function handleCreateProject(event: FormEvent<HTMLFormElement>) {
+    event.preventDefault();
+
+    if (!pickedFolder) {
+      setCreateError("Выбери папку сайта или перетащи её в область импорта.");
+      return;
+    }
+
+    await createProjectFromFolder(pickedFolder, pendingProjectName || pickedFolder.rootName);
+  }
+
   function startProjectRename(project: ProjectSummary) {
     renameCancelRef.current = false;
     setEditingProjectId(project.id);
@@ -2180,10 +4656,30 @@ export function App() {
         ...currentAnalyses,
         [result.project.id]: null
       }));
+      setProjectOntologies((currentOntologies) => ({
+        ...currentOntologies,
+        [result.project.id]: null
+      }));
       setMarketEnrichments((currentEnrichments) => ({
         ...currentEnrichments,
         [result.project.id]: null
       }));
+      setKeywordMaps((currentKeywordMaps) => ({
+        ...currentKeywordMaps,
+        [result.project.id]: null
+      }));
+      setRewritePlans((currentRewritePlans) => ({
+        ...currentRewritePlans,
+        [result.project.id]: null
+      }));
+      setMaterializationContracts((currentContracts) => ({
+        ...currentContracts,
+        [result.project.id]: null
+      }));
+      setRewriteDiffContracts((currentContracts) => ({
+        ...currentContracts,
+        [result.project.id]: null
+      }));
       setProjectActionProjectId(result.project.id);
       setProjectActionMessage(`Создана копия «${result.project.name}».`);
     } catch (error: unknown) {
@@ -2210,10 +4706,35 @@ export function App() {
         ...currentAnalyses,
         [project.id]: null
       }));
+      setProjectOntologies((currentOntologies) => ({
+        ...currentOntologies,
+        [project.id]: null
+      }));
       setMarketEnrichments((currentEnrichments) => ({
         ...currentEnrichments,
         [project.id]: null
       }));
+      setKeywordMaps((currentKeywordMaps) => ({
+        ...currentKeywordMaps,
+        [project.id]: null
+      }));
+      setSeoStrategies((currentStrategies) => ({
+        ...currentStrategies,
+        [project.id]: null
+      }));
+      setRewritePlans((currentRewritePlans) => ({
+        ...currentRewritePlans,
+        [project.id]: null
+      }));
+      setMaterializationContracts((currentContracts) => ({
+        ...currentContracts,
+        [project.id]: null
+      }));
+      setRewriteDiffContracts((currentContracts) => ({
+        ...currentContracts,
+        [project.id]: null
+      }));
+      invalidateStrategyQualityReview(project.id);
       if (!options.hideSuccessMessage) {
         setProjectActionMessage(getProjectScanActionMessage(result.scan));
       }
@@ -2237,15 +4758,67 @@ export function App() {
         ...currentAnalyses,
         [project.id]: result.analysis
       }));
+      setContextReviews((currentReviews) => ({
+        ...currentReviews,
+        [project.id]: null
+      }));
       setActiveSemanticClusterIds((currentIds) => ({
         ...currentIds,
         [project.id]: result.analysis.clusters[0]?.id ?? ""
       }));
-      const marketResult = await fetchLatestMarketEnrichment(project.id);
+      const [
+        ontologyResult,
+        marketResult,
+        keywordCleaningResult,
+        keywordMapResult,
+        strategyResult,
+        rewritePlanResult,
+        materializationResult,
+        rewriteDiffResult
+      ] =
+        await Promise.all([
+        fetchLatestProjectOntology(project.id),
+        fetchLatestMarketEnrichment(project.id),
+        fetchLatestKeywordCleaning(project.id),
+        fetchLatestKeywordMap(project.id),
+        fetchLatestSeoStrategy(project.id),
+        fetchLatestRewritePlan(project.id),
+        fetchLatestMaterialization(project.id),
+        fetchLatestRewriteDiff(project.id)
+      ]);
+      setProjectOntologies((currentOntologies) => ({
+        ...currentOntologies,
+        [project.id]: ontologyResult.ontology
+      }));
       setMarketEnrichments((currentEnrichments) => ({
         ...currentEnrichments,
         [project.id]: marketResult.marketEnrichment
       }));
+      setKeywordCleanings((currentKeywordCleanings) => ({
+        ...currentKeywordCleanings,
+        [project.id]: keywordCleaningResult.keywordCleaning
+      }));
+      setKeywordMaps((currentKeywordMaps) => ({
+        ...currentKeywordMaps,
+        [project.id]: keywordMapResult.keywordMap
+      }));
+      setSeoStrategies((currentStrategies) => ({
+        ...currentStrategies,
+        [project.id]: strategyResult.strategy
+      }));
+      setRewritePlans((currentRewritePlans) => ({
+        ...currentRewritePlans,
+        [project.id]: rewritePlanResult.rewritePlan
+      }));
+      setMaterializationContracts((currentContracts) => ({
+        ...currentContracts,
+        [project.id]: materializationResult.materialization
+      }));
+      setRewriteDiffContracts((currentContracts) => ({
+        ...currentContracts,
+        [project.id]: rewriteDiffResult.rewriteDiff
+      }));
+      invalidateStrategyQualityReview(project.id);
       setProjectActionMessage(getSemanticAnalysisMessage(result.analysis));
     } catch (error: unknown) {
       setProjectActionError(getErrorMessage(error, "Не удалось выполнить semantic analysis."));
@@ -2279,6 +4852,252 @@ export function App() {
     }
   }
 
+  async function handleSeoContextReview(project: ProjectSummary) {
+    setReviewingContextProjectId(project.id);
+    setProjectActionError(null);
+    setProjectActionMessage(null);
+    setProjectActionProjectId(project.id);
+
+    try {
+      const result = await runSeoContextReview(project.id);
+      const [marketResult, keywordCleaningResult, keywordMapResult, strategyResult, rewritePlanResult, materializationResult, rewriteDiffResult] = await Promise.all([
+        fetchLatestMarketEnrichment(project.id),
+        fetchLatestKeywordCleaning(project.id),
+        fetchLatestKeywordMap(project.id),
+        fetchLatestSeoStrategy(project.id),
+        fetchLatestRewritePlan(project.id),
+        fetchLatestMaterialization(project.id),
+        fetchLatestRewriteDiff(project.id)
+      ]);
+
+      setContextReviews((currentReviews) => ({
+        ...currentReviews,
+        [project.id]: result.contextReview
+      }));
+      setMarketEnrichments((currentEnrichments) => ({
+        ...currentEnrichments,
+        [project.id]: marketResult.marketEnrichment
+      }));
+      setKeywordCleanings((currentKeywordCleanings) => ({
+        ...currentKeywordCleanings,
+        [project.id]: keywordCleaningResult.keywordCleaning
+      }));
+      setKeywordMaps((currentKeywordMaps) => ({
+        ...currentKeywordMaps,
+        [project.id]: keywordMapResult.keywordMap
+      }));
+      setSeoStrategies((currentStrategies) => ({
+        ...currentStrategies,
+        [project.id]: strategyResult.strategy
+      }));
+      setRewritePlans((currentRewritePlans) => ({
+        ...currentRewritePlans,
+        [project.id]: rewritePlanResult.rewritePlan
+      }));
+      setMaterializationContracts((currentContracts) => ({
+        ...currentContracts,
+        [project.id]: materializationResult.materialization
+      }));
+      setRewriteDiffContracts((currentContracts) => ({
+        ...currentContracts,
+        [project.id]: rewriteDiffResult.rewriteDiff
+      }));
+      invalidateStrategyQualityReview(project.id);
+      setProjectActionMessage(
+        `Context Review сохранён: ${result.contextReview.readiness.normalizationHintCount} hints, ${result.contextReview.readiness.forbiddenClaimCount} forbidden claims.`
+      );
+    } catch (error: unknown) {
+      setProjectActionError(getErrorMessage(error, "Не удалось сохранить context review."));
+    } finally {
+      setReviewingContextProjectId(null);
+    }
+  }
+
+  async function handleSeoModelTaskRun(project: ProjectSummary, taskType: SeoModelTaskType) {
+    const taskKey = `${project.id}:${taskType}`;
+    setRunningModelTaskKey(taskKey);
+    setProjectActionError(null);
+    setProjectActionMessage(null);
+    setProjectActionProjectId(project.id);
+
+    try {
+      const result = await runSeoModelTask(project.id, {
+        providerId: "codex_manual",
+        taskType
+      });
+      const statusResult = await fetchModelProviderStatus(project.id);
+
+      setModelProviderStatuses((currentStatuses) => ({
+        ...currentStatuses,
+        [project.id]: statusResult.modelProvider
+      }));
+      setProjectActionMessage(
+        `${getModelTaskTypeLabel(taskType)} Codex task route: ${getModelTaskRunStatusLabel(result.modelTaskRun.status)} · ~${
+          result.modelTaskRun.estimate.inputTokenEstimate
+        } input tokens.`
+      );
+    } catch (error: unknown) {
+      setProjectActionError(getErrorMessage(error, "Не удалось подготовить Codex task route."));
+    } finally {
+      setRunningModelTaskKey(null);
+    }
+  }
+
+  async function handleProjectOntologyApproval(
+    project: ProjectSummary,
+    ontology: ProjectOntologyVersion,
+    status: ProjectOntologyApprovalStatus
+  ) {
+    const approvalKey = `${project.id}:${ontology.id}:${status}`;
+    setApprovingOntologyKey(approvalKey);
+    setProjectActionError(null);
+    setProjectActionMessage(null);
+    setProjectActionProjectId(project.id);
+
+    try {
+      const result = await updateProjectOntologyApproval(project.id, ontology.id, status);
+
+      setProjectOntologies((currentOntologies) => ({
+        ...currentOntologies,
+        [project.id]: result.ontology
+      }));
+      setSemanticAnalyses((currentAnalyses) => {
+        const currentAnalysis = currentAnalyses[project.id];
+
+        if (!currentAnalysis?.projectOntology || currentAnalysis.projectOntology.versionId !== result.ontology.id) {
+          return currentAnalyses;
+        }
+
+        return {
+          ...currentAnalyses,
+          [project.id]: {
+            ...currentAnalysis,
+            projectOntology: {
+              ...currentAnalysis.projectOntology,
+              instance: currentAnalysis.projectOntology.instance
+                ? {
+                    ...currentAnalysis.projectOntology.instance,
+                    approvalStatus: result.ontology.approvalStatus
+                  }
+                : currentAnalysis.projectOntology.instance
+            }
+          }
+        };
+      });
+      const [marketResult, keywordCleaningResult, keywordMapResult, strategyResult, rewritePlanResult, materializationResult, rewriteDiffResult] = await Promise.all([
+        fetchLatestMarketEnrichment(project.id),
+        fetchLatestKeywordCleaning(project.id),
+        fetchLatestKeywordMap(project.id),
+        fetchLatestSeoStrategy(project.id),
+        fetchLatestRewritePlan(project.id),
+        fetchLatestMaterialization(project.id),
+        fetchLatestRewriteDiff(project.id)
+      ]);
+      setMarketEnrichments((currentEnrichments) => ({
+        ...currentEnrichments,
+        [project.id]: marketResult.marketEnrichment
+      }));
+      setKeywordCleanings((currentKeywordCleanings) => ({
+        ...currentKeywordCleanings,
+        [project.id]: keywordCleaningResult.keywordCleaning
+      }));
+      setKeywordMaps((currentKeywordMaps) => ({
+        ...currentKeywordMaps,
+        [project.id]: keywordMapResult.keywordMap
+      }));
+      setSeoStrategies((currentStrategies) => ({
+        ...currentStrategies,
+        [project.id]: strategyResult.strategy
+      }));
+      setRewritePlans((currentRewritePlans) => ({
+        ...currentRewritePlans,
+        [project.id]: rewritePlanResult.rewritePlan
+      }));
+      setMaterializationContracts((currentContracts) => ({
+        ...currentContracts,
+        [project.id]: materializationResult.materialization
+      }));
+      setRewriteDiffContracts((currentContracts) => ({
+        ...currentContracts,
+        [project.id]: rewriteDiffResult.rewriteDiff
+      }));
+      invalidateStrategyQualityReview(project.id);
+      setProjectActionMessage(`Project ontology v${result.ontology.version}: ${getProjectOntologyApprovalLabel(result.ontology.approvalStatus)}.`);
+    } catch (error: unknown) {
+      setProjectActionError(getErrorMessage(error, "Не удалось обновить project ontology."));
+    } finally {
+      setApprovingOntologyKey(null);
+    }
+  }
+
+  async function handleProjectOntologyConfirmation(
+    project: ProjectSummary,
+    ontology: ProjectOntologyVersion,
+    input: {
+      aliasesConfirmed?: boolean;
+      brandConfirmed?: boolean;
+    }
+  ) {
+    const confirmationType = typeof input.brandConfirmed === "boolean" ? "brand" : "aliases";
+    const confirmationKey = `${project.id}:${ontology.id}:${confirmationType}`;
+    setConfirmingOntologyKey(confirmationKey);
+    setProjectActionError(null);
+    setProjectActionMessage(null);
+    setProjectActionProjectId(project.id);
+
+    try {
+      const result = await updateProjectOntologyConfirmations(project.id, ontology.id, input);
+      const [marketResult, keywordCleaningResult, keywordMapResult, strategyResult, rewritePlanResult, materializationResult, rewriteDiffResult] = await Promise.all([
+        fetchLatestMarketEnrichment(project.id),
+        fetchLatestKeywordCleaning(project.id),
+        fetchLatestKeywordMap(project.id),
+        fetchLatestSeoStrategy(project.id),
+        fetchLatestRewritePlan(project.id),
+        fetchLatestMaterialization(project.id),
+        fetchLatestRewriteDiff(project.id)
+      ]);
+
+      setProjectOntologies((currentOntologies) => ({
+        ...currentOntologies,
+        [project.id]: result.ontology
+      }));
+      setMarketEnrichments((currentEnrichments) => ({
+        ...currentEnrichments,
+        [project.id]: marketResult.marketEnrichment
+      }));
+      setKeywordCleanings((currentKeywordCleanings) => ({
+        ...currentKeywordCleanings,
+        [project.id]: keywordCleaningResult.keywordCleaning
+      }));
+      setKeywordMaps((currentKeywordMaps) => ({
+        ...currentKeywordMaps,
+        [project.id]: keywordMapResult.keywordMap
+      }));
+      setSeoStrategies((currentStrategies) => ({
+        ...currentStrategies,
+        [project.id]: strategyResult.strategy
+      }));
+      setRewritePlans((currentRewritePlans) => ({
+        ...currentRewritePlans,
+        [project.id]: rewritePlanResult.rewritePlan
+      }));
+      setMaterializationContracts((currentContracts) => ({
+        ...currentContracts,
+        [project.id]: materializationResult.materialization
+      }));
+      setRewriteDiffContracts((currentContracts) => ({
+        ...currentContracts,
+        [project.id]: rewriteDiffResult.rewriteDiff
+      }));
+      invalidateStrategyQualityReview(project.id);
+      setProjectActionMessage(`Project ontology v${result.ontology.version}: confirmations обновлены.`);
+    } catch (error: unknown) {
+      setProjectActionError(getErrorMessage(error, "Не удалось обновить confirmations project ontology."));
+    } finally {
+      setConfirmingOntologyKey(null);
+    }
+  }
+
   async function handleMarketEnrichment(project: ProjectSummary) {
     setEnrichingMarketProjectId(project.id);
     setProjectActionError(null);
@@ -2292,6 +5111,39 @@ export function App() {
         ...currentEnrichments,
         [project.id]: result.marketEnrichment
       }));
+      const [keywordCleaningResult, keywordMapResult, strategyResult, rewritePlanResult, materializationResult, rewriteDiffResult] = await Promise.all([
+        fetchLatestKeywordCleaning(project.id),
+        fetchLatestKeywordMap(project.id),
+        fetchLatestSeoStrategy(project.id),
+        fetchLatestRewritePlan(project.id),
+        fetchLatestMaterialization(project.id),
+        fetchLatestRewriteDiff(project.id)
+      ]);
+      setKeywordCleanings((currentKeywordCleanings) => ({
+        ...currentKeywordCleanings,
+        [project.id]: keywordCleaningResult.keywordCleaning
+      }));
+      setKeywordMaps((currentKeywordMaps) => ({
+        ...currentKeywordMaps,
+        [project.id]: keywordMapResult.keywordMap
+      }));
+      setSeoStrategies((currentStrategies) => ({
+        ...currentStrategies,
+        [project.id]: strategyResult.strategy
+      }));
+      setRewritePlans((currentRewritePlans) => ({
+        ...currentRewritePlans,
+        [project.id]: rewritePlanResult.rewritePlan
+      }));
+      setMaterializationContracts((currentContracts) => ({
+        ...currentContracts,
+        [project.id]: materializationResult.materialization
+      }));
+      setRewriteDiffContracts((currentContracts) => ({
+        ...currentContracts,
+        [project.id]: rewriteDiffResult.rewriteDiff
+      }));
+      invalidateStrategyQualityReview(project.id);
       setProjectActionMessage(
         result.marketEnrichment.state === "not_configured"
           ? "Market enrichment готов к запуску, но платформенный provider ещё не настроен."
@@ -2304,6 +5156,204 @@ export function App() {
     }
   }
 
+  async function handleYandexEvidence(project: ProjectSummary) {
+    setCollectingYandexEvidenceProjectId(project.id);
+    setProjectActionError(null);
+    setProjectActionMessage(null);
+    setProjectActionProjectId(project.id);
+
+    try {
+      const result = await runYandexEvidence(project.id, 5);
+      const strategyResult = await fetchLatestSeoStrategy(project.id);
+
+      setYandexEvidences((currentEvidences) => ({
+        ...currentEvidences,
+        [project.id]: result.yandexEvidence
+      }));
+      setSerpInterpretations((currentInterpretations) => ({
+        ...currentInterpretations,
+        [project.id]: null
+      }));
+      setStrategySyntheses((currentSyntheses) => ({
+        ...currentSyntheses,
+        [project.id]: null
+      }));
+      invalidateStrategyQualityReview(project.id);
+      setSeoStrategies((currentStrategies) => ({
+        ...currentStrategies,
+        [project.id]: strategyResult.strategy
+      }));
+      setProjectActionMessage(
+        `Yandex evidence собрано: ${result.yandexEvidence.summary.checkedPhraseCount} фраз, ${formatCount(
+          result.yandexEvidence.summary.totalDemand
+        )} спрос, ${result.yandexEvidence.summary.serpDocCount} SERP docs.`
+      );
+    } catch (error: unknown) {
+      setProjectActionError(getErrorMessage(error, "Не удалось собрать Yandex evidence."));
+    } finally {
+      setCollectingYandexEvidenceProjectId(null);
+    }
+  }
+
+  async function handleSerpInterpretation(project: ProjectSummary) {
+    setInterpretingSerpProjectId(project.id);
+    setProjectActionError(null);
+    setProjectActionMessage(null);
+    setProjectActionProjectId(project.id);
+
+    try {
+      const result = await runSerpInterpretation(project.id);
+      const strategyResult = await fetchLatestSeoStrategy(project.id);
+
+      setSerpInterpretations((currentInterpretations) => ({
+        ...currentInterpretations,
+        [project.id]: result.serpInterpretation
+      }));
+      setSeoStrategies((currentStrategies) => ({
+        ...currentStrategies,
+        [project.id]: strategyResult.strategy
+      }));
+      setStrategySyntheses((currentSyntheses) => ({
+        ...currentSyntheses,
+        [project.id]: null
+      }));
+      invalidateStrategyQualityReview(project.id);
+      setProjectActionMessage(
+        `SERP interpretation: ${result.serpInterpretation.readiness.interpretedPhraseCount} фраз, ${result.serpInterpretation.readiness.competitorGapCount} competitor gaps, ${result.serpInterpretation.readiness.mismatchCount} mismatch.`
+      );
+    } catch (error: unknown) {
+      setProjectActionError(getErrorMessage(error, "Не удалось собрать SERP interpretation."));
+    } finally {
+      setInterpretingSerpProjectId(null);
+    }
+  }
+
+  async function handleStrategySynthesis(project: ProjectSummary) {
+    setSynthesizingStrategyProjectId(project.id);
+    setProjectActionError(null);
+    setProjectActionMessage(null);
+    setProjectActionProjectId(project.id);
+
+    try {
+      const result = await runStrategySynthesis(project.id);
+
+      setStrategySyntheses((currentSyntheses) => ({
+        ...currentSyntheses,
+        [project.id]: result.strategySynthesis
+      }));
+      invalidateStrategyQualityReview(project.id);
+      setProjectActionMessage(
+        `Strategy synthesis: ${result.strategySynthesis.readiness.decisionOptionCount} опции, ${result.strategySynthesis.readiness.dataGapCount} gaps, score ${result.strategySynthesis.readiness.confidenceScore}.`
+      );
+    } catch (error: unknown) {
+      setProjectActionError(getErrorMessage(error, "Не удалось собрать strategy synthesis."));
+    } finally {
+      setSynthesizingStrategyProjectId(null);
+    }
+  }
+
+  async function handleStrategyQualityReview(project: ProjectSummary) {
+    setReviewingStrategyQualityProjectId(project.id);
+    setProjectActionError(null);
+    setProjectActionMessage(null);
+    setProjectActionProjectId(project.id);
+
+    try {
+      const result = await runStrategyQualityReview(project.id);
+
+      setStrategyQualityReviews((currentReviews) => ({
+        ...currentReviews,
+        [project.id]: result.strategyQualityReview
+      }));
+      setProjectActionMessage(
+        `Strategy quality: ${getStrategyQualityVerdictLabel(result.strategyQualityReview.verdict.status)}, score ${
+          result.strategyQualityReview.readiness.score
+        }, blockers ${result.strategyQualityReview.readiness.blockerCount}.`
+      );
+    } catch (error: unknown) {
+      setProjectActionError(getErrorMessage(error, "Не удалось собрать strategy quality review."));
+    } finally {
+      setReviewingStrategyQualityProjectId(null);
+    }
+  }
+
+  async function handleApproveKeywordMapDecisions(project: ProjectSummary) {
+    setPersistingKeywordMapProjectId(project.id);
+    setProjectActionError(null);
+    setProjectActionMessage(null);
+    setProjectActionProjectId(project.id);
+
+    try {
+      const result = await approveKeywordMapDecisions(project.id);
+      const [strategyResult, rewritePlanResult, materializationResult, rewriteDiffResult] = await Promise.all([
+        fetchLatestSeoStrategy(project.id),
+        fetchLatestRewritePlan(project.id),
+        fetchLatestMaterialization(project.id),
+        fetchLatestRewriteDiff(project.id)
+      ]);
+
+      setKeywordMaps((currentKeywordMaps) => ({
+        ...currentKeywordMaps,
+        [project.id]: result.keywordMap
+      }));
+      setSeoStrategies((currentStrategies) => ({
+        ...currentStrategies,
+        [project.id]: strategyResult.strategy
+      }));
+      setRewritePlans((currentRewritePlans) => ({
+        ...currentRewritePlans,
+        [project.id]: rewritePlanResult.rewritePlan
+      }));
+      setMaterializationContracts((currentContracts) => ({
+        ...currentContracts,
+        [project.id]: materializationResult.materialization
+      }));
+      setRewriteDiffContracts((currentContracts) => ({
+        ...currentContracts,
+        [project.id]: rewriteDiffResult.rewriteDiff
+      }));
+      invalidateStrategyQualityReview(project.id);
+      setProjectActionMessage(
+        `Keyword decisions сохранены: ${result.savedDecisionCount}, map items: ${result.savedMapItemCount}, skipped: ${result.skippedItemCount}.`
+      );
+    } catch (error: unknown) {
+      setProjectActionError(getErrorMessage(error, "Не удалось сохранить keyword decisions."));
+    } finally {
+      setPersistingKeywordMapProjectId(null);
+    }
+  }
+
+  async function handleMaterializationAction(project: ProjectSummary, input: MaterializationActionInput) {
+    const targetKey = `${project.id}:${input.targetPath}:${input.action}`;
+    setMaterializingTargetKey(targetKey);
+    setProjectActionError(null);
+    setProjectActionMessage(null);
+    setProjectActionProjectId(project.id);
+
+    try {
+      const result = await applyMaterializationAction(project.id, input);
+
+      setMaterializationContracts((currentContracts) => ({
+        ...currentContracts,
+        [project.id]: result.materialization
+      }));
+      setRewritePlans((currentRewritePlans) => ({
+        ...currentRewritePlans,
+        [project.id]: result.rewritePlan
+      }));
+      const rewriteDiffResult = await fetchLatestRewriteDiff(project.id);
+      setRewriteDiffContracts((currentContracts) => ({
+        ...currentContracts,
+        [project.id]: rewriteDiffResult.rewriteDiff
+      }));
+      setProjectActionMessage(`Очередь посадочных обновлена: ${result.updatedMapItemCount} привязок фраз.`);
+    } catch (error: unknown) {
+      setProjectActionError(getErrorMessage(error, "Не удалось применить решение по посадочной."));
+    } finally {
+      setMaterializingTargetKey(null);
+    }
+  }
+
   async function handleProjectPageSelection(project: ProjectSummary, pageIds: string[], selected: boolean) {
     if (pageIds.length === 0) {
       return;
@@ -2732,6 +5782,31 @@ export function App() {
         delete nextAnalyses[project.id];
         return nextAnalyses;
       });
+      setProjectOntologies((currentOntologies) => {
+        const nextOntologies = { ...currentOntologies };
+        delete nextOntologies[project.id];
+        return nextOntologies;
+      });
+      setMarketEnrichments((currentEnrichments) => {
+        const nextEnrichments = { ...currentEnrichments };
+        delete nextEnrichments[project.id];
+        return nextEnrichments;
+      });
+      setKeywordCleanings((currentKeywordCleanings) => {
+        const nextKeywordCleanings = { ...currentKeywordCleanings };
+        delete nextKeywordCleanings[project.id];
+        return nextKeywordCleanings;
+      });
+      setKeywordMaps((currentKeywordMaps) => {
+        const nextKeywordMaps = { ...currentKeywordMaps };
+        delete nextKeywordMaps[project.id];
+        return nextKeywordMaps;
+      });
+      setRewritePlans((currentRewritePlans) => {
+        const nextRewritePlans = { ...currentRewritePlans };
+        delete nextRewritePlans[project.id];
+        return nextRewritePlans;
+      });
       setActiveSemanticClusterIds((currentIds) => {
         const nextIds = { ...currentIds };
         delete nextIds[project.id];
@@ -2801,13 +5876,78 @@ export function App() {
     });
   }
 
-  const activeProject =
-    (activeProjectId ? projects.find((project) => project.id === activeProjectId) : null) ?? projects[0] ?? null;
+  const activeProject = activeProjectId ? (projects.find((project) => project.id === activeProjectId) ?? null) : null;
   const activeProjectScanSummary = activeProject ? scanSummaries[activeProject.id] : null;
+  const activeSemanticAnalysis = activeProject ? (semanticAnalyses[activeProject.id] ?? null) : null;
+  const activeContextReviewRaw = activeProject ? (contextReviews[activeProject.id] ?? null) : null;
+  const activeContextReview =
+    activeSemanticAnalysis && activeContextReviewRaw?.semanticRunId === activeSemanticAnalysis.runId
+      ? activeContextReviewRaw
+      : null;
+  const activeMarketEnrichment = activeProject ? (marketEnrichments[activeProject.id] ?? null) : null;
+  const activeKeywordMap = activeProject ? (keywordMaps[activeProject.id] ?? null) : null;
+  const activeSeoStrategy = activeProject ? (seoStrategies[activeProject.id] ?? null) : null;
+  const activeStrategySynthesis = activeProject ? (strategySyntheses[activeProject.id] ?? null) : null;
+  const activeStrategyQualityReview = activeProject ? (strategyQualityReviews[activeProject.id] ?? null) : null;
+  const activeProjectScanScopeCounts = activeProjectScanSummary ? getScanScopeCounts(activeProjectScanSummary) : null;
+  const activeProjectSelectedWorkspaceScopeItems = activeProjectScanSummary
+    ? getSelectedWorkspaceScopeItems(activeProjectScanSummary)
+    : [];
+  const activeProjectWorkspaceScopeId =
+    activeProject && activeProjectScanSummary
+      ? (activeWorkspaceScopeIds[activeProject.id] ?? activeProjectSelectedWorkspaceScopeItems[0]?.scopeId ?? null)
+      : null;
+  const activeProjectWorkspaceScopeItem =
+    activeProjectSelectedWorkspaceScopeItems.find((item) => item.scopeId === activeProjectWorkspaceScopeId) ??
+    activeProjectSelectedWorkspaceScopeItems[0] ??
+    null;
+  const activeProjectWorkspaceKey =
+    activeProject && activeProjectWorkspaceScopeItem
+      ? getWorkspaceKey(activeProject.id, activeProjectWorkspaceScopeItem.scopeId)
+      : null;
+  const activeProjectWorkspace = activeProjectWorkspaceKey ? pageWorkspaces[activeProjectWorkspaceKey] : null;
+  const activeProjectWorkspaceIssues = getPageIssues(activeProjectScanSummary, activeProjectWorkspaceScopeItem?.pageId ?? null);
+  const activeProjectWorkspaceTargets = activeProjectWorkspace
+    ? buildWorkspaceTargets(activeProjectWorkspace, activeProjectWorkspaceIssues)
+    : [];
+  const activeProjectWorkspacePreviewMode = activeProjectWorkspaceKey
+    ? (workspacePreviewModes[activeProjectWorkspaceKey] ?? "desktop")
+    : "desktop";
+  const activeProjectWorkspaceDrawers = activeProject
+    ? WORKSPACE_DRAWER_ORDER.filter((drawer) => (workspaceDrawers[activeProject.id] ?? []).includes(drawer))
+    : [];
+  const activeProjectWorkspacePageIndex = Math.max(
+    0,
+    activeProjectSelectedWorkspaceScopeItems.findIndex((item) => item.scopeId === activeProjectWorkspaceScopeItem?.scopeId)
+  );
+  const activeProjectSiteTitle = getProjectSiteTitle(activeProjectScanSummary);
+  const isActiveProjectSelectingPages = activeProject ? selectingPagesProjectId === activeProject.id : false;
+  const isActiveProjectScanning = activeProject ? scanningProjectId === activeProject.id : false;
+  const canConfirmActiveProjectScope = Boolean(
+    activeProject &&
+      activeProjectScanSummary &&
+      !isActiveProjectSelectingPages &&
+      !isActiveProjectScanning &&
+      (activeProjectScanScopeCounts?.selectedIndexable ?? 0) > 0
+  );
   const hasActiveProjectScanEntry = activeProject
     ? Object.prototype.hasOwnProperty.call(scanSummaries, activeProject.id)
     : false;
   const visibleProjects = activeStageIndex === 0 ? projects : activeProject ? [activeProject] : [];
+  const stageAccessList = pipeline.map((_, stageIndex) =>
+    getPipelineStageAccess(stageIndex, {
+      contextReview: activeContextReview,
+      hasProject: Boolean(activeProject),
+      keywordMap: activeKeywordMap,
+      marketEnrichment: activeMarketEnrichment,
+      scan: activeProjectScanSummary,
+      semanticAnalysis: activeSemanticAnalysis,
+      seoStrategy: activeSeoStrategy,
+      strategyQualityReview: activeStrategyQualityReview,
+      strategySynthesis: activeStrategySynthesis
+    })
+  );
+  const activeStageAccess = stageAccessList[activeStageIndex] ?? stageAccessList[0];
 
   useEffect(() => {
     if (
@@ -2866,9 +6006,86 @@ export function App() {
     }
   }, [activeWorkspaceScopeIds, busyWorkspaceKey, pageWorkspaces, projects, scanSummaries, workspacePreviewScopeIds]);
 
-  const createNameConflict = pickedFolder ? hasProjectNameConflict(pickedFolder.rootName) : false;
-  const canCreateProject = Boolean(pickedFolder) && !isSubmitting && !createNameConflict;
+  const createName = pendingProjectName.trim();
+  const createNameConflict = Boolean(createName) && hasProjectNameConflict(createName);
+  const canCreateProject = Boolean(pickedFolder && createName) && !isSubmitting && !createNameConflict;
   const activeStage = stageMeta[activeStageIndex] ?? stageMeta[3];
+  const topbarHeading =
+    activeProject && activeStageIndex === 1
+      ? {
+          title: "Подтвердить конфигурацию проекта",
+          subtitle: "Выбранные посадочные попадут в рабочую зону, контекстный анализ, спрос и стратегию."
+        }
+      : activeProject && activeStageIndex === 2 && activeProjectWorkspaceScopeItem
+        ? {
+            title: activeProjectWorkspaceScopeItem.title,
+            subtitle: activeProjectWorkspace?.page.title ?? activeProjectSiteTitle
+          }
+        : {
+            title: workspaceMode === "dev" ? activeStage.title : "Автоматический SEO-процесс",
+            subtitle: workspaceMode === "dev" ? `Dev Mode · этап ${activeStageIndex + 1}` : "Auto Mode · целевой слой"
+          };
+  const topbarStageActions =
+    activeProject && activeProjectScanSummary && activeStageIndex === 1 ? (
+      <button
+        className="seo-topbar-primary-action"
+        disabled={!canConfirmActiveProjectScope}
+        onClick={() => void confirmProjectConfiguration(activeProject, activeProjectScanSummary)}
+        type="button"
+      >
+        <CheckCircle2 size={16} />
+        Подтвердить
+      </button>
+    ) : activeProject && activeStageIndex === 2 && activeProjectWorkspaceScopeItem ? (
+      <div className="seo-topbar-workspace-actions">
+        <button
+          className={activeProjectWorkspaceDrawers.includes("pages") ? "active" : undefined}
+          onClick={() => toggleWorkspaceDrawer(activeProject.id, "pages")}
+          type="button"
+        >
+          <FileText size={14} />
+          Страница
+          <em>
+            {activeProjectWorkspacePageIndex + 1}/{activeProjectSelectedWorkspaceScopeItems.length}
+          </em>
+          <ChevronDown size={14} />
+        </button>
+        <button
+          className={activeProjectWorkspaceDrawers.includes("issues") ? "active" : undefined}
+          onClick={() => toggleWorkspaceDrawer(activeProject.id, "issues")}
+          type="button"
+        >
+          <CircleAlert size={14} />
+          Ошибки
+          <em>{activeProjectWorkspaceTargets.length}</em>
+        </button>
+        <div className="seo-topbar-preview-mode-switch" aria-label="Режим зеркала">
+          {WORKSPACE_PREVIEW_MODES.map((mode) => (
+            <button
+              className={activeProjectWorkspacePreviewMode === mode.id ? "active" : undefined}
+              disabled={!activeProjectWorkspaceKey}
+              key={mode.id}
+              onClick={() => {
+                if (!activeProjectWorkspaceKey) {
+                  return;
+                }
+
+                changeWorkspacePreviewMode(
+                  activeProjectWorkspaceKey,
+                  mode.id,
+                  activeProjectWorkspaceTargets,
+                  activeProjectSelectedWorkspaceScopeItems,
+                  activeProjectWorkspaceScopeItem
+                );
+              }}
+              type="button"
+            >
+              {mode.label}
+            </button>
+          ))}
+        </div>
+      </div>
+    ) : null;
 
   function openProjectScanStage(project: ProjectSummary) {
     if (editingProjectId === project.id || pendingDeleteProjectId === project.id) {
@@ -2877,102 +6094,197 @@ export function App() {
 
     setActiveProjectId(project.id);
     setActiveStageIndex(1);
+    setIsProjectMenuOpen(false);
+    setIsWorkPanelOpen(true);
+    setIsWorkPanelFullscreen(false);
 
     window.requestAnimationFrame(() => {
       document.querySelector(".topbar")?.scrollIntoView({ behavior: "smooth", block: "start" });
     });
   }
 
+  function openProjectFromMenu(project: ProjectSummary) {
+    const nextStageIndex = activeProjectId === project.id ? activeStageIndex : 1;
+
+    setActiveProjectId(project.id);
+    setActiveStageIndex(nextStageIndex);
+    setIsProjectMenuOpen(false);
+    setIsWorkPanelOpen(false);
+    setIsWorkPanelFullscreen(false);
+  }
+
+  function closeActiveProject() {
+    setActiveProjectId(null);
+    setActiveStageIndex(0);
+    setIsProjectMenuOpen(false);
+    setIsWorkPanelOpen(false);
+    setIsWorkPanelFullscreen(false);
+  }
+
+  function closeWorkPanel() {
+    setIsWorkPanelOpen(false);
+    setIsWorkPanelFullscreen(false);
+  }
+
+  function handlePipelineStageClick(stageIndex: number) {
+    const access = stageAccessList[stageIndex];
+
+    if (!access?.unlocked) {
+      setProjectActionProjectId(null);
+      setProjectActionError(null);
+      setProjectActionMessage(access?.reason ?? "Этот этап пока недоступен.");
+      return;
+    }
+
+    setActiveStageIndex(stageIndex);
+    setIsWorkPanelOpen(true);
+  }
+
+  function confirmProjectConfiguration(project: ProjectSummary, scan: ProjectScanSummary) {
+    const scopeCounts = getScanScopeCounts(scan);
+
+    if (!isScanReadyForFlow(scan) || scopeCounts.selectedIndexable === 0) {
+      setProjectActionProjectId(project.id);
+      setProjectActionError("Сначала нужен успешный скан и хотя бы одна выбранная посадочная страница.");
+      setProjectActionMessage(null);
+      return;
+    }
+
+    setProjectActionProjectId(project.id);
+    setProjectActionError(null);
+    setProjectActionMessage(
+      `Конфигурация подтверждена: ${scopeCounts.selectedIndexable}/${scopeCounts.indexable} посадочных идут в SEO-пайплайн.`
+    );
+    setActiveStageIndex(2);
+  }
+
   return (
-    <div className="app-shell">
-      <header className="app-header">
-        <div className="brand-block" aria-label="seo_mode">
-          <div className="brand-mark"><span>sm</span></div>
-          <div>
-            <h1>seo_mode</h1>
-            <p>SEO workspace</p>
+    <div
+      className={`app-shell seo-launcher-shell ${activeProject ? "project-open" : "zero-state"} ${
+        activeProject && isWorkPanelOpen ? "content-open" : ""
+      } ${
+        activeProject && isWorkPanelOpen && isWorkPanelFullscreen ? "work-fullscreen" : ""
+      }`}
+    >
+      <header className="app-header nodedc-expanded-toolbar-shell">
+        <div className="nodedc-expanded-toolbar">
+          <div className="nodedc-expanded-toolbar-top">
+            <div className="nodedc-expanded-toolbar-left">
+              <a className="nodedc-expanded-brand-link" href="/" aria-label="NODE.DC">
+                <img className="nodedc-expanded-brand-logo" src="/nodedc-logo.svg" alt="NODE.DC" />
+              </a>
+            </div>
+
+            <div className="nodedc-expanded-toolbar-center">
+              <div className="seo-project-menu">
+                <button
+                  aria-expanded={isProjectMenuOpen}
+                  className="nodedc-expanded-nav-button seo-project-menu-trigger"
+                  data-active="true"
+                  onClick={() => setIsProjectMenuOpen((current) => !current)}
+                  type="button"
+                >
+                  <span>Проекты</span>
+                </button>
+
+                {isProjectMenuOpen ? (
+                  <div className="seo-project-menu-popover" role="menu">
+                    <div className="seo-project-menu-head">
+                      <span>SEO Mode</span>
+                      <strong>{activeProject ? activeProject.name : "Выберите проект"}</strong>
+                    </div>
+                    {projectsLoading ? (
+                      <div className="seo-project-menu-empty">
+                        <Loader2 className="spin" size={16} />
+                        Загружаю проекты...
+                      </div>
+                    ) : projects.length === 0 ? (
+                      <div className="seo-project-menu-empty">
+                        <FolderCheck size={16} />
+                        Проектов пока нет
+                      </div>
+                    ) : (
+                      <div className="seo-project-menu-list">
+                        {projects.map((project) => {
+                          const scanSummary = scanSummaries[project.id];
+                          const isCurrent = activeProjectId === project.id;
+
+                          return (
+                            <button
+                              className={isCurrent ? "active" : ""}
+                              key={project.id}
+                              onClick={() => openProjectFromMenu(project)}
+                              role="menuitem"
+                              type="button"
+                            >
+                              <span>{isCurrent ? <CheckCircle2 size={14} /> : <FolderOpen size={14} />}</span>
+                              <strong>{project.name}</strong>
+                              <small>
+                                {scanSummary
+                                  ? `${scanSummary.counts.pages} страниц · ${scanSummary.counts.assets} ассетов`
+                                  : "ждёт инициализации"}
+                              </small>
+                            </button>
+                          );
+                        })}
+                      </div>
+                    )}
+                    <button className="seo-project-menu-add" onClick={closeActiveProject} type="button">
+                      <Plus size={15} />
+                      Добавить проект
+                    </button>
+                  </div>
+                ) : null}
+              </div>
+
+              <div className="workspace-mode-switch seo-header-mode-switch" aria-label="Режим SEO-модуля" role="group">
+                <button
+                  aria-pressed={workspaceMode === "dev"}
+                  className={workspaceMode === "dev" ? "active" : ""}
+                  onClick={() => setWorkspaceMode("dev")}
+                  type="button"
+                >
+                  Dev Mode
+                </button>
+                <button
+                  aria-pressed={workspaceMode === "auto"}
+                  className={workspaceMode === "auto" ? "active" : ""}
+                  onClick={() => setWorkspaceMode("auto")}
+                  type="button"
+                >
+                  Auto Mode
+                </button>
+              </div>
+            </div>
+
+            <div className="nodedc-expanded-toolbar-right">
+              <div className="nodedc-expanded-user-group">
+                <button
+                  className="nodedc-toolbar-icon-button nodedc-expanded-notification-button"
+                  data-active={health ? "true" : "false"}
+                  onClick={openExternalServicesModal}
+                  title={health ? "Настройки и внешние сервисы" : (healthError ?? "Бэкенд ждёт запуска")}
+                  type="button"
+                  aria-label="Настройки"
+                >
+                  <span className="nodedc-toolbar-icon-active-dot">
+                    <Settings size={19} strokeWidth={1.8} />
+                  </span>
+                </button>
+                <div className="nodedc-expanded-profile-trigger" title="SEO workspace">
+                  <span className="nodedc-expanded-nav-button" data-active="false">
+                    <span>Профиль</span>
+                  </span>
+                  <span className="nodedc-expanded-user-avatar-button" aria-hidden="true">
+                    <span className="nodedc-expanded-user-avatar">
+                      <UserCircle size={22} />
+                    </span>
+                  </span>
+                </div>
+              </div>
+            </div>
           </div>
         </div>
-
-        <nav className="nav-list" aria-label="Основная навигация">
-          {pipeline.map((item, index) => (
-            <button
-              aria-pressed={index === activeStageIndex}
-              className={index === activeStageIndex ? "nav-item active" : "nav-item"}
-              key={item}
-              onClick={() => setActiveStageIndex(index)}
-              type="button"
-            >
-              <span>{String(index + 1).padStart(2, "0")}</span>
-              <strong>{item}</strong>
-            </button>
-          ))}
-        </nav>
-
-        <details className="system-status-menu">
-          <summary aria-label="Технический статус системы">
-            <Settings size={18} />
-          </summary>
-          <div className="system-status-popover">
-            <div className={health ? "status-pill ok" : "status-pill warning"}>
-              <Activity size={16} />
-              {health ? "Бэкенд работает" : "Бэкенд ждёт запуска"}
-            </div>
-            <button className="system-settings-action" onClick={openExternalServicesModal} type="button">
-              <Plug size={16} />
-              <span>Внешние сервисы</span>
-            </button>
-            <article className="status-card compact">
-              <Server size={18} />
-              <div>
-                <h3>Бэкенд</h3>
-                <p>{health ? "Сервер seo_mode отвечает" : (healthError ?? "Ждём ответ от /health")}</p>
-              </div>
-            </article>
-            <article className="status-card compact">
-              <Database size={18} />
-              <div>
-                <h3>Postgres</h3>
-                <p>Состояние проекта, версии и решения</p>
-              </div>
-            </article>
-            <article className="status-card compact">
-              <Archive size={18} />
-              <div>
-                <h3>MinIO/S3</h3>
-                <p>Артефакты, снимки, отчёты и экспорты</p>
-              </div>
-            </article>
-            <details className="system-subsection">
-              <summary>
-                <FolderCheck size={16} />
-                <span>Ближайший кусок сборки</span>
-              </summary>
-              <div className="task-table system-task-table">
-                <div className="task-row done">
-                  <span>01</span>
-                  <p>Рабочая папка, TypeScript, проверка бэкенда, React-каркас</p>
-                </div>
-                <div className="task-row done">
-                  <span>02</span>
-                  <p>Миграции Postgres и модель источника проекта</p>
-                </div>
-                <div className="task-row done">
-                  <span>03</span>
-                  <p>Создание, переименование, копирование и удаление проекта</p>
-                </div>
-                <div className="task-row done">
-                  <span>04</span>
-                  <p>Версия скана, список страниц и ассетов, сверка изменений</p>
-                </div>
-                <div className="task-row active">
-                  <span>05</span>
-                  <p>projectIndex.json и базовый аудит title/description/headings/media</p>
-                </div>
-              </div>
-            </details>
-          </div>
-        </details>
       </header>
 
       {isExternalServicesOpen ? (
@@ -2994,8 +6306,9 @@ export function App() {
                 </span>
                 <h2 id="external-services-title">Внешние сервисы</h2>
                 <p>
-                  Сейчас нужен один Yandex Cloud credential для Wordstat. SERP позже использует его же; Webmaster и
-                  Metrica остаются отдельными OAuth-слоями.
+                  Сейчас нужен один Yandex AI Studio / Cloud credential: folderId и API key. Wordstat, SERP/WebSearch
+                  и будущий model layer используют его по ролям service account; Webmaster и Metrica подключаются после
+                  деплоя сайта.
                 </p>
               </div>
               <button
@@ -3149,12 +6462,51 @@ export function App() {
                         ))}
                       </div>
 
+                      {service.id === "yandex_cloud" && yandexAiStudioProbe ? (
+                        <div className="service-probe-result">
+                          <div>
+                            <strong>Capability probe</strong>
+                            <span>
+                              {yandexAiStudioProbe.credential.configured
+                                ? `${yandexAiStudioProbe.credential.authType} · ${yandexAiStudioProbe.credential.folderId}`
+                                : "credential not configured"}
+                            </span>
+                          </div>
+                          <ul>
+                            {yandexAiStudioProbe.capabilities.map((capability) => (
+                              <li className={capability.ok ? "ok" : "error"} key={capability.id}>
+                                <span>{capability.label}</span>
+                                <small>
+                                  {capability.ok ? "ok" : "fail"} · {capability.status ?? "no response"} ·{" "}
+                                  {capability.ms} ms · {capability.summary}
+                                </small>
+                              </li>
+                            ))}
+                          </ul>
+                        </div>
+                      ) : null}
+
                       <div className="service-card-footer">
                         <small>
                           {service.implementationStatus === "active"
                             ? "Этот provider уже подключается к backend pipeline."
                             : "Настройки сохраняются заранее; backend adapter будет подключён отдельным слоем."}
                         </small>
+                        {service.id === "yandex_cloud" ? (
+                          <button
+                            className="tiny-action"
+                            disabled={isSaving || probingExternalServiceId === service.id}
+                            onClick={() => void handleProbeYandexAiStudioCredential()}
+                            type="button"
+                          >
+                            {probingExternalServiceId === service.id ? (
+                              <Loader2 className="spin" size={14} />
+                            ) : (
+                              <RefreshCw size={14} />
+                            )}
+                            {probingExternalServiceId === service.id ? "Проверяю..." : "Проверить"}
+                          </button>
+                        ) : null}
                         <button
                           className="tiny-action primary"
                           disabled={isSaving}
@@ -3179,34 +6531,164 @@ export function App() {
         </div>
       ) : null}
 
+      {isProjectNameModalOpen && pickedFolder ? (
+        <div
+          className="seo-project-name-modal-backdrop"
+          onMouseDown={(event) => {
+            if (event.target === event.currentTarget && !isSubmitting) {
+              clearPickedFolder();
+            }
+          }}
+          role="presentation"
+        >
+          <form className="seo-project-name-modal" onSubmit={handleCreateProject}>
+            <div className="seo-project-name-modal-head">
+              <span>Новый SEO project</span>
+              <button
+                aria-label="Закрыть"
+                disabled={isSubmitting}
+                onClick={clearPickedFolder}
+                type="button"
+              >
+                <X size={17} />
+              </button>
+            </div>
+            <label className="service-field">
+              <span>Название проекта</span>
+              <input
+                autoFocus
+                onChange={(event) => setPendingProjectName(event.target.value)}
+                placeholder={pickedFolder.rootName}
+                value={pendingProjectName}
+              />
+              <small>
+                Источник: {pickedFolder.rootName} · {getFolderStats(pickedFolder).fileCount} файлов ·{" "}
+                {formatBytes(getFolderStats(pickedFolder).totalBytes)}
+              </small>
+            </label>
+            {createNameConflict ? (
+              <p className="form-message error">
+                <CircleAlert size={16} />
+                <span>Проект с названием «{createName}» уже есть.</span>
+              </p>
+            ) : null}
+            {createError ? (
+              <p className="form-message error">
+                <CircleAlert size={16} />
+                <span>{createError}</span>
+              </p>
+            ) : null}
+            <div className="seo-project-name-modal-actions">
+              <button className="tiny-action" disabled={isSubmitting} onClick={clearPickedFolder} type="button">
+                Отмена
+              </button>
+              <button className="primary-action" disabled={!canCreateProject} type="submit">
+                {isSubmitting ? <Loader2 className="spin" size={16} /> : <Plus size={16} />}
+                {isSubmitting ? "Создаю..." : "OK"}
+              </button>
+            </div>
+          </form>
+        </div>
+      ) : null}
+
       <main className={`workspace stage-${activeStageIndex + 1}`}>
+        <section className="seo-zero-stage" aria-label="NodeDC SEO Mode">
+          <div className="stage-video-shell">
+            <div className="stage-video-stream" aria-hidden="true">
+              <video className="stage-video-gif" src="/media/home.mp4" autoPlay loop muted playsInline preload="metadata" />
+            </div>
+            <div className="stage-empty-title" aria-label="NodeDC SEO Mode">
+              <span>NODE.DC</span>
+              <strong>SEO Mode</strong>
+            </div>
+          </div>
+        </section>
+
+        {activeProject ? (
+          <aside className="seo-stage-rail" aria-label="Этапы SEO Mode">
+            <div className="seo-stage-rail-head">
+              <span>SEO Mode</span>
+              <strong>{activeProject.name}</strong>
+              <small>{activeProjectScanSummary ? "проект инициализирован" : "ждёт инициализации"}</small>
+            </div>
+            <nav className="seo-stage-rail-list" aria-label="Навигация по этапам">
+              {pipeline.map((item, index) => {
+                const access = stageAccessList[index];
+                const isActive = index === activeStageIndex;
+
+                return (
+                  <button
+                    aria-disabled={!access.unlocked}
+                    aria-pressed={isActive}
+                    className={`${isActive ? "active" : ""} ${access.unlocked ? "unlocked" : "locked"}`.trim()}
+                    disabled={!access.unlocked}
+                    key={item}
+                    onClick={() => handlePipelineStageClick(index)}
+                    title={access.reason}
+                    type="button"
+                  >
+                    <span>{String(index + 1).padStart(2, "0")}</span>
+                    <strong>{item}</strong>
+                    <small>{stageMeta[index]?.sectionTitle ?? item}</small>
+                  </button>
+                );
+              })}
+            </nav>
+          </aside>
+        ) : null}
+
+        {!activeProject || isWorkPanelOpen ? (
+        <section className={activeProject ? "seo-work-panel" : "seo-work-panel zero-work-panel"} aria-label="Рабочая панель SEO Mode">
         <header className="topbar">
-          <div>
-            <p className="eyebrow">
-              {workspaceMode === "dev" ? `Dev Mode · этап ${activeStageIndex + 1}` : "Auto Mode · целевой слой"}
-            </p>
-            <h2>{workspaceMode === "dev" ? activeStage.title : "Автоматический SEO-процесс"}</h2>
-          </div>
-          <div className="workspace-mode-switch" aria-label="Режим SEO-модуля" role="group">
-            <button
-              aria-pressed={workspaceMode === "dev"}
-              className={workspaceMode === "dev" ? "active" : ""}
-              onClick={() => setWorkspaceMode("dev")}
-              type="button"
-            >
-              Dev Mode
-            </button>
-            <button
-              aria-pressed={workspaceMode === "auto"}
-              className={workspaceMode === "auto" ? "active" : ""}
-              onClick={() => setWorkspaceMode("auto")}
-              type="button"
-            >
-              Auto Mode
-            </button>
+          <div className="seo-work-panel-heading">
+            <h2>{topbarHeading.title}</h2>
+            <p>{topbarHeading.subtitle}</p>
           </div>
+          {activeProject ? (
+            <div className="seo-work-panel-toolbar">
+              {topbarStageActions}
+              <div className="seo-work-panel-actions">
+                <button
+                  aria-label={isWorkPanelFullscreen ? "Свернуть рабочую панель" : "Открыть рабочую панель на весь экран"}
+                  onClick={() => setIsWorkPanelFullscreen((current) => !current)}
+                  title={isWorkPanelFullscreen ? "Свернуть" : "Fullscreen"}
+                  type="button"
+                >
+                  {isWorkPanelFullscreen ? <Minimize2 size={16} /> : <Maximize2 size={16} />}
+                </button>
+                <button aria-label="Закрыть рабочую панель" onClick={closeWorkPanel} title="Закрыть панель" type="button">
+                  <X size={17} />
+                </button>
+              </div>
+            </div>
+          ) : null}
         </header>
 
+        {workspaceMode === "dev" ? (
+          <section className={`flow-status-strip ${activeStageAccess.unlocked ? "ready" : "locked"}`}>
+            <div>
+              <span>{activeStageAccess.unlocked ? "этап доступен" : "этап закрыт"}</span>
+              <strong>{activeProject ? activeProject.name : "Проект не выбран"}</strong>
+              <small>{activeStageAccess.reason}</small>
+            </div>
+            {activeProject ? (
+              <div className="flow-status-metrics">
+                <span>{activeProjectScanSummary ? "инициализирован" : "ждёт инициализации"}</span>
+                <span>
+                  {activeProjectScanSummary
+                    ? `${activeProjectScanSummary.counts.pages} страниц · ${activeProjectScanSummary.counts.assets} ассетов`
+                    : "нет scan contract"}
+                </span>
+                <span>{activeSeoStrategy ? getSeoMaturityPhaseLabel(activeSeoStrategy.siteMaturity.phase) : "стратегия не собрана"}</span>
+              </div>
+            ) : (
+              <button className="tiny-action" onClick={() => setActiveStageIndex(0)} type="button">
+                Выбрать проект
+              </button>
+            )}
+          </section>
+        ) : null}
+
         {workspaceMode === "auto" ? (
           <section className="auto-mode-shell" aria-labelledby="auto-mode-title">
             <div className="auto-mode-heading">
@@ -3254,58 +6736,72 @@ export function App() {
         ) : null}
 
         <section className={workspaceMode === "auto" ? "project-setup mode-hidden" : "project-setup"} aria-labelledby="project-setup-title">
-          <div className="section-heading">
-            <FolderOpen size={20} />
-            <div>
-              <h3 id="project-setup-title">{activeStage.sectionTitle}</h3>
-              {activeStageIndex === 1 && activeProject ? (
-                <>
-                  <div className="section-project-title-row">
-                    {editingProjectId === activeProject.id ? (
-                      <input
-                        aria-label="Новое название проекта"
-                        className="project-title-input section-project-title-input"
-                        onBlur={() => void commitProjectRename(activeProject)}
-                        onChange={(event) => setEditingProjectName(event.target.value)}
-                        onKeyDown={(event) => {
-                          if (event.key === "Enter") {
-                            event.preventDefault();
-                            void commitProjectRename(activeProject);
-                          }
+          {activeStageIndex === 1 ? null : (
+            <div className="section-heading">
+              <FolderOpen size={20} />
+              <div>
+                <h3 id="project-setup-title">{activeStage.sectionTitle}</h3>
+                {activeStageIndex === 1 && activeProject ? (
+                  <>
+                    <div className="section-project-title-row">
+                      {editingProjectId === activeProject.id ? (
+                        <input
+                          aria-label="Новое название проекта"
+                          className="project-title-input section-project-title-input"
+                          onBlur={() => void commitProjectRename(activeProject)}
+                          onChange={(event) => setEditingProjectName(event.target.value)}
+                          onKeyDown={(event) => {
+                            if (event.key === "Enter") {
+                              event.preventDefault();
+                              void commitProjectRename(activeProject);
+                            }
 
-                          if (event.key === "Escape") {
-                            event.preventDefault();
-                            cancelProjectRename();
-                          }
-                        }}
-                        ref={titleInputRef}
-                        value={editingProjectName}
-                      />
-                    ) : (
-                      <button
-                        className="section-project-title project-title"
-                        onDoubleClick={() => startProjectRename(activeProject)}
-                        title="Двойной клик, чтобы переименовать"
-                        type="button"
-                      >
-                        {activeProject.name}
-                      </button>
-                    )}
-                    {busyProjectId === activeProject.id && editingProjectId === activeProject.id ? (
-                      <Loader2 className="spin project-title-loader" size={16} />
+                            if (event.key === "Escape") {
+                              event.preventDefault();
+                              cancelProjectRename();
+                            }
+                          }}
+                          ref={titleInputRef}
+                          value={editingProjectName}
+                        />
+                      ) : (
+                        <button
+                          className="section-project-title project-title"
+                          onDoubleClick={() => startProjectRename(activeProject)}
+                          title="Двойной клик, чтобы переименовать"
+                          type="button"
+                        >
+                          {activeProject.name}
+                        </button>
+                      )}
+                      {busyProjectId === activeProject.id && editingProjectId === activeProject.id ? (
+                        <Loader2 className="spin project-title-loader" size={16} />
+                      ) : null}
+                    </div>
+                    {editingProjectId === activeProject.id && editingProjectName.trim().length === 0 ? (
+                      <small className="field-warning section-title-warning">Название не должно быть пустым.</small>
                     ) : null}
+                    {editingProjectId === activeProject.id && hasProjectNameConflict(editingProjectName, activeProject.id) ? (
+                      <small className="field-warning section-title-warning">Проект с таким названием уже есть.</small>
+                    ) : null}
+                  </>
+                ) : null}
+                <p>{activeStage.description}</p>
+                {activeProject ? (
+                  <div className="seo-stage-summary-row">
+                    <span>{activeStageAccess.unlocked ? "этап доступен" : "этап закрыт"}</span>
+                    <span>{activeProjectScanSummary ? "инициализирован" : "ждёт инициализации"}</span>
+                    {activeProjectScanSummary ? (
+                      <span>
+                        {activeProjectScanSummary.counts.pages} страниц · {activeProjectScanSummary.counts.assets} ассетов
+                      </span>
+                    ) : null}
+                    <span>{activeSeoStrategy ? getSeoMaturityPhaseLabel(activeSeoStrategy.siteMaturity.phase) : "Bootstrap / indexing"}</span>
                   </div>
-                  {editingProjectId === activeProject.id && editingProjectName.trim().length === 0 ? (
-                    <small className="field-warning section-title-warning">Название не должно быть пустым.</small>
-                  ) : null}
-                  {editingProjectId === activeProject.id && hasProjectNameConflict(editingProjectName, activeProject.id) ? (
-                    <small className="field-warning section-title-warning">Проект с таким названием уже есть.</small>
-                  ) : null}
-                </>
-              ) : null}
-              <p>{activeStage.description}</p>
+                ) : null}
+              </div>
             </div>
-          </div>
+          )}
 
           <div className="project-grid">
             <form className="project-form" onSubmit={handleCreateProject}>
@@ -3328,9 +6824,9 @@ export function App() {
                   />
                   <button className="folder-pick-action" onClick={() => void handlePickFolder()} type="button">
                     <UploadCloud size={16} />
-                    Выбрать папку
+                    Добавить проект
                   </button>
-                  <span>или перетащи папку сюда, чтобы импортировать файлы</span>
+                  <span>перетащи папку или архив сюда, чтобы импортировать файлы</span>
                 </div>
                 {isSubmitting ? (
                   <div className="folder-picker-message-row folder-upload-status" aria-live="polite">
@@ -3433,7 +6929,43 @@ export function App() {
                   {visibleProjects.map((project) => {
                     const scanSummary = scanSummaries[project.id];
                     const semanticAnalysis = semanticAnalyses[project.id] ?? null;
+                    const contextReview = contextReviews[project.id] ?? null;
+                    const isContextReviewAligned = Boolean(
+                      semanticAnalysis && contextReview && contextReview.semanticRunId === semanticAnalysis.runId
+                    );
+                    const activeContextReview = isContextReviewAligned ? contextReview : null;
+                    const projectOntology = projectOntologies[project.id] ?? null;
                     const marketEnrichment = marketEnrichments[project.id] ?? null;
+                    const keywordCleaning = keywordCleanings[project.id] ?? null;
+                    const keywordMap = keywordMaps[project.id] ?? null;
+                    const seoStrategy = seoStrategies[project.id] ?? null;
+                    const yandexEvidence = yandexEvidences[project.id] ?? null;
+                    const serpInterpretation = serpInterpretations[project.id] ?? null;
+                    const strategySynthesis = strategySyntheses[project.id] ?? null;
+                    const strategyQualityReview = strategyQualityReviews[project.id] ?? null;
+                    const rewritePlan = rewritePlans[project.id] ?? null;
+                    const materialization = materializationContracts[project.id] ?? null;
+                    const rewriteDiff = rewriteDiffContracts[project.id] ?? null;
+                    const stageDecisionFrame = stageDecisionFrames[activeStageIndex] ?? null;
+                    const marketDecision = marketEnrichment ? getMarketDecision(marketEnrichment) : null;
+                    const keywordPlanDecision = keywordMap ? getKeywordPlanDecision(keywordMap) : null;
+                    const keywordPagePlans = keywordMap ? getKeywordPlanPageSummaries(keywordMap) : [];
+                    const keywordReviewItems = keywordMap ? getKeywordPlanReviewItems(keywordMap) : [];
+                    const normalizationReviewQueues = marketEnrichment
+                      ? {
+                          human: marketEnrichment.normalization.seedStrategy.filter(
+                            (seed) => seed.review.status === "needs_human"
+                          ),
+                          rejected: marketEnrichment.normalization.seedStrategy.filter(
+                            (seed) => seed.review.status === "rejected"
+                          ),
+                          serp: marketEnrichment.normalization.seedStrategy.filter((seed) => seed.review.sendToSerp),
+                          wordstat: marketEnrichment.normalization.seedStrategy.filter((seed) => seed.review.sendToWordstat)
+                        }
+                      : null;
+                    const ontologyConfirmations = projectOntology?.evidenceSummary.confirmations;
+                    const isBrandConfirmed = ontologyConfirmations?.brand.confirmed ?? false;
+                    const isAliasesConfirmed = ontologyConfirmations?.aliases.confirmed ?? false;
                     const activeSemanticClusterId =
                       semanticAnalysis ? (activeSemanticClusterIds[project.id] ?? semanticAnalysis.clusters[0]?.id ?? "") : "";
                     const activeSemanticCluster =
@@ -3442,7 +6974,44 @@ export function App() {
                       null;
                     const isScanning = scanningProjectId === project.id;
                     const isAnalyzing = analyzingProjectId === project.id;
+                    const isReviewingContext = reviewingContextProjectId === project.id;
                     const isEnrichingMarket = enrichingMarketProjectId === project.id;
+                    const isInterpretingSerp = interpretingSerpProjectId === project.id;
+                    const isSynthesizingStrategy = synthesizingStrategyProjectId === project.id;
+                    const isReviewingStrategyQuality = reviewingStrategyQualityProjectId === project.id;
+                    const isPersistingKeywordMap = persistingKeywordMapProjectId === project.id;
+                    const modelProviderStatus = modelProviderStatuses[project.id] ?? null;
+                    const defaultModelProvider =
+                      modelProviderStatus?.catalog.providers.find(
+                        (provider) => provider.id === modelProviderStatus.catalog.defaultProviderId
+                      ) ??
+                      modelProviderStatus?.catalog.providers[0] ??
+                      null;
+                    const latestModelTaskRun = modelProviderStatus?.latestRuns[0] ?? null;
+                    const isRunningContextModelTask = runningModelTaskKey === `${project.id}:seo.context_review`;
+                    const isRunningNormalizationModelTask = runningModelTaskKey === `${project.id}:seo.normalization`;
+                    const isRunningKeywordCleaningModelTask = runningModelTaskKey === `${project.id}:seo.keyword_cleaning`;
+                    const isRunningSerpInterpretationModelTask =
+                      runningModelTaskKey === `${project.id}:seo.serp_interpretation`;
+                    const isRunningStrategySynthesisModelTask =
+                      runningModelTaskKey === `${project.id}:seo.strategy_synthesis`;
+                    const isRunningStrategyQualityModelTask =
+                      runningModelTaskKey === `${project.id}:seo.strategy_quality_review`;
+                    const canPrepareStrategySynthesis = Boolean(
+                      seoStrategy &&
+                        serpInterpretation?.state === "ready" &&
+                        seoStrategy.evidence.serpInterpretation.state === "ready" &&
+                        seoStrategy.opportunities.length > 0
+                    );
+                    const canPrepareStrategyQualityReview = Boolean(
+                      strategySynthesis?.state === "ready" &&
+                        strategySynthesis.decisionOptions.length > 0 &&
+                        seoStrategy?.phasePlan.length
+                    );
+                    const selectedStrategyPhaseId = seoStrategy
+                      ? (selectedStrategyPhaseIds[project.id] ?? seoStrategy.siteMaturity.phase)
+                      : null;
+                    const selectedStrategyPhase = seoStrategy?.phasePlan.find((phase) => phase.phase === selectedStrategyPhaseId) ?? null;
                     const isExportingSemantic = exportingSemanticKey?.startsWith(`${project.id}:`) ?? false;
                     const isSelectingPages = selectingPagesProjectId === project.id;
                     const selectedPagesCount = scanSummary ? getSelectedPagesCount(scanSummary) : 0;
@@ -3610,6 +7179,19 @@ export function App() {
                                 ? getProjectScanStatusMessage(scanSummary)
                                 : "Скан ещё не запускался."}
                           </div>
+                          {activeStageIndex === 0 ? (
+                            <div className="project-flow-actions">
+                              <button
+                                className="tiny-action primary"
+                                disabled={isScanning}
+                                onClick={() => openProjectScanStage(project)}
+                                type="button"
+                              >
+                                {isScanning ? <Loader2 className="spin" size={14} /> : <GitBranch size={14} />}
+                                {scanSummary ? "Открыть процесс" : "Инициализировать"}
+                              </button>
+                            </div>
+                          ) : null}
 
                           {activeStageIndex === 1 ? (
                             <div className="page-audit-overview">
@@ -3829,7 +7411,7 @@ export function App() {
                                   <section className="semantic-panel">
                                     <div className="semantic-heading">
                                       <div>
-                                        <strong>Semantic analysis NodeDC</strong>
+                                        <strong>Анализ контекста</strong>
                                         <small>{getSemanticRunDate(semanticAnalysis)}</small>
                                       </div>
                                       <div className="semantic-heading-actions">
@@ -3864,6 +7446,167 @@ export function App() {
                                     </div>
                                     {semanticAnalysis ? (
                                       <>
+                                        <section className="semantic-review-summary">
+                                          <div className="semantic-review-card semantic-context-card">
+                                            <span>Контекст сайта</span>
+                                            <strong>
+                                              {semanticAnalysis.projectOntology?.brandName ??
+                                                projectOntology?.brandName ??
+                                                project.name}
+                                            </strong>
+                                            <small>
+                                              {semanticAnalysis.analysisVerdict?.summary ??
+                                                "Детерминированный анализ собрал текст, meta, headings, JSON-контент и первичные intent clusters."}
+                                            </small>
+                                          </div>
+
+                                          <div className="semantic-review-card">
+                                            <span>Уверенность</span>
+                                            <strong>
+                                              {semanticAnalysis.analysisVerdict
+                                                ? getSemanticVerdictConfidenceLabel(semanticAnalysis.analysisVerdict.confidence)
+                                                : `${semanticAnalysis.summary.coverageScore}% готовности`}
+                                            </strong>
+                                            <small>
+                                              Доказательность {semanticAnalysis.summary.evidenceScore ?? semanticAnalysis.summary.coverageScore}% ·
+                                              интенты {semanticAnalysis.summary.intentCoverageScore ?? semanticAnalysis.summary.coverageScore}% ·
+                                              рынок{" "}
+                                              {semanticAnalysis.analysisVerdict
+                                                ? getSemanticVerdictObjectivityLabel(semanticAnalysis.analysisVerdict.marketObjectivity)
+                                                : "не проверен"}
+                                            </small>
+                                          </div>
+
+                                          <div className="semantic-review-card">
+                                            <span>Что найдено</span>
+                                            <strong>
+                                              {semanticAnalysis.summary.coveredClusters} покрыто · {semanticAnalysis.summary.weakClusters} слабо ·{" "}
+                                              {semanticAnalysis.summary.missingClusters} пусто
+                                            </strong>
+                                            <small>
+                                              Страницы {semanticAnalysis.pageScope.indexablePages} · JSON{" "}
+                                              {semanticAnalysis.pageScope.contentSources} · seed phrases{" "}
+                                              {semanticAnalysis.summary.seedCandidates}
+                                            </small>
+                                          </div>
+
+                                          <div
+                                            className={`semantic-review-card ${
+                                              semanticAnalysis.summary.qualityProblems > 0 || semanticAnalysis.summary.legacyFindings > 0
+                                                ? "problem"
+                                                : semanticAnalysis.summary.qualityWarnings > 0
+                                                  ? "warning"
+                                                  : "ok"
+                                            }`}
+                                          >
+                                            <span>Риски</span>
+                                            <strong>
+                                              {semanticAnalysis.summary.qualityProblems + semanticAnalysis.summary.legacyFindings > 0
+                                                ? "Есть blockers"
+                                                : semanticAnalysis.summary.qualityWarnings > 0
+                                                  ? "Есть warnings"
+                                                  : "Критичных рисков нет"}
+                                            </strong>
+                                            <small>
+                                              Legacy {semanticAnalysis.summary.legacyFindings} · problems{" "}
+                                              {semanticAnalysis.summary.qualityProblems} · warnings {semanticAnalysis.summary.qualityWarnings}
+                                            </small>
+                                          </div>
+                                        </section>
+
+                                        <section className="semantic-context-summary">
+                                          <div>
+                                            <strong>Что сайт сейчас говорит</strong>
+                                            <small>
+                                              Короткая выжимка из видимого текста, headings, meta и JSON-контента. Это основа для
+                                              проверки спроса, а не финальный SEO-план.
+                                            </small>
+                                          </div>
+                                          <div className="semantic-context-tags">
+                                            {semanticAnalysis.styleProfile.topTerms.slice(0, 8).map((term) => (
+                                              <span key={term.term}>
+                                                {term.term} · {term.count}
+                                              </span>
+                                            ))}
+                                            {semanticAnalysis.clusters.slice(0, 5).map((cluster) => (
+                                              <span className={cluster.status} key={cluster.id}>
+                                                {cluster.title}
+                                              </span>
+                                            ))}
+                                          </div>
+                                        </section>
+
+                                        <section
+                                          className={`seo-context-review-card ${
+                                            activeContextReview
+                                              ? activeContextReview.needsHumanReview
+                                                ? "warning"
+                                                : "ready"
+                                              : contextReview
+                                                ? "stale"
+                                                : "missing"
+                                          }`}
+                                        >
+                                          <div>
+                                            <span>AI Context Review</span>
+                                            <strong>
+                                              {activeContextReview
+                                                ? activeContextReview.needsHumanReview
+                                                  ? "Сохранён, нужна проверка"
+                                                  : "Сохранён"
+                                                : contextReview
+                                                  ? "Устарел после нового анализа"
+                                                  : "Не сохранён"}
+                                            </strong>
+                                            <small>
+                                              {activeContextReview
+                                                ? `${formatDate(activeContextReview.generatedAt)} · ${activeContextReview.summary}`
+                                                : "Сохранённый review нужен перед рыночным спросом: forbidden claims, ambiguity и normalization hints."}
+                                            </small>
+                                          </div>
+                                          <div className="seo-context-review-metrics">
+                                            <span>{activeContextReview?.provider.mode === "codex_manual" ? "Codex" : "Fallback"}</span>
+                                            <span>{activeContextReview?.analystReview.status ?? "not_reviewed"}</span>
+                                            <span>Hints {activeContextReview?.readiness.normalizationHintCount ?? 0}</span>
+                                            <span>Forbidden {activeContextReview?.readiness.forbiddenClaimCount ?? 0}</span>
+                                            <span>Gaps {activeContextReview?.readiness.semanticGapCount ?? 0}</span>
+                                            <span>Review {activeContextReview?.readiness.needsHumanReview ? "yes" : "no"}</span>
+                                          </div>
+                                          <button
+                                            className="tiny-action primary"
+                                            disabled={!semanticAnalysis || isReviewingContext}
+                                            onClick={() => void handleSeoContextReview(project)}
+                                            type="button"
+                                          >
+                                            {isReviewingContext ? <Loader2 className="spin" size={14} /> : <Save size={14} />}
+                                            {isReviewingContext
+                                              ? "Сохраняю..."
+                                              : activeContextReview
+                                                ? "Обновить review"
+                                                : "Сохранить review"}
+                                          </button>
+                                        </section>
+
+                                        <div className="seo-chart-grid">
+                                          <SeoBarChart
+                                            items={getSemanticScoreBars(semanticAnalysis)}
+                                            subtitle="0-100, до внешнего рынка"
+                                            title="Готовность контекста"
+                                          />
+                                          <SeoBarChart
+                                            items={getSemanticClusterBars(semanticAnalysis)}
+                                            subtitle="что сайт уже объясняет и где пустоты"
+                                            title="Смысловое покрытие"
+                                          />
+                                        </div>
+
+                                        <details className="semantic-dev-details">
+                                          <summary>
+                                            <span>Технические детали</span>
+                                            <strong>Открыть диагностику контекста</strong>
+                                            <small>Кластеры, snippets, источники, gaps, briefs и seed candidates.</small>
+                                          </summary>
+                                          <div className="semantic-dev-details-body">
                                         <div className="semantic-score-grid">
                                           <div className="semantic-score-main">
                                             <span>{semanticAnalysis.summary.coverageScore}%</span>
@@ -3900,6 +7643,169 @@ export function App() {
                                           </div>
                                         </div>
 
+                                        {semanticAnalysis.projectOntology ? (
+                                          <>
+                                            <div className="semantic-scope-grid">
+                                              <div>
+                                                <strong>Project ontology</strong>
+                                                <small>
+                                                  {projectOntology?.brandName ?? semanticAnalysis.projectOntology.brandName} ·{" "}
+                                                  {getProjectOntologySourceLabel(
+                                                    projectOntology?.source ?? semanticAnalysis.projectOntology.source
+                                                  )}{" "}
+                                                  · seo@
+                                                  {projectOntology?.domainPackage.version ??
+                                                    semanticAnalysis.projectOntology.domainPackage.version}
+                                                </small>
+                                              </div>
+                                              <span>
+                                                Version:{" "}
+                                                {projectOntology
+                                                  ? `v${projectOntology.version}`
+                                                  : semanticAnalysis.projectOntology.version
+                                                    ? `v${semanticAnalysis.projectOntology.version}`
+                                                    : "not saved"}
+                                              </span>
+                                              <span>
+                                                Status:{" "}
+                                                {projectOntology
+                                                  ? getProjectOntologyApprovalLabel(projectOntology.approvalStatus)
+                                                  : semanticAnalysis.projectOntology.instance
+                                                    ? getProjectOntologyApprovalLabel(
+                                                        semanticAnalysis.projectOntology.instance.approvalStatus
+                                                      )
+                                                    : "none"}
+                                              </span>
+                                              <span>
+                                                Pages:{" "}
+                                                {projectOntology?.evidenceSummary.pageCount ??
+                                                  semanticAnalysis.projectOntology.instance?.pageCount ??
+                                                  0}
+                                              </span>
+                                              <span>
+                                                Intents:{" "}
+                                                {projectOntology?.evidenceSummary.intentClusterCount ??
+                                                  semanticAnalysis.projectOntology.instance?.intentClusterCount ??
+                                                  0}
+                                              </span>
+                                            </div>
+
+                                            {projectOntology ? (
+                                              <details className="scan-help">
+                                                <summary>Evidence и approval для project ontology</summary>
+                                                <div className="semantic-heading-actions">
+                                                  {(["approved", "needs_review", "rejected"] as const).map((status) => {
+                                                    const approvalKey = `${project.id}:${projectOntology.id}:${status}`;
+
+                                                    return (
+                                                      <button
+                                                        className={status === "approved" ? "tiny-action primary" : "tiny-action"}
+                                                        disabled={Boolean(approvingOntologyKey)}
+                                                        key={status}
+                                                        onClick={() => void handleProjectOntologyApproval(project, projectOntology, status)}
+                                                        type="button"
+                                                      >
+                                                        {approvingOntologyKey === approvalKey ? (
+                                                          <Loader2 className="spin" size={14} />
+                                                        ) : status === "approved" ? (
+                                                          <CheckCircle2 size={14} />
+                                                        ) : (
+                                                          <CircleAlert size={14} />
+                                                        )}
+                                                        {getProjectOntologyApprovalLabel(status)}
+                                                      </button>
+                                                    );
+                                                  })}
+                                                </div>
+                                                <div className="semantic-heading-actions">
+                                                  <button
+                                                    className={isBrandConfirmed ? "tiny-action primary" : "tiny-action"}
+                                                    disabled={Boolean(confirmingOntologyKey)}
+                                                    onClick={() =>
+                                                      void handleProjectOntologyConfirmation(project, projectOntology, {
+                                                        brandConfirmed: !isBrandConfirmed
+                                                      })
+                                                    }
+                                                    type="button"
+                                                  >
+                                                    {confirmingOntologyKey === `${project.id}:${projectOntology.id}:brand` ? (
+                                                      <Loader2 className="spin" size={14} />
+                                                    ) : isBrandConfirmed ? (
+                                                      <CheckCircle2 size={14} />
+                                                    ) : (
+                                                      <CircleAlert size={14} />
+                                                    )}
+                                                    {isBrandConfirmed ? "Brand confirmed" : "Confirm brand"}
+                                                  </button>
+                                                  <button
+                                                    className={isAliasesConfirmed ? "tiny-action primary" : "tiny-action"}
+                                                    disabled={Boolean(confirmingOntologyKey)}
+                                                    onClick={() =>
+                                                      void handleProjectOntologyConfirmation(project, projectOntology, {
+                                                        aliasesConfirmed: !isAliasesConfirmed
+                                                      })
+                                                    }
+                                                    type="button"
+                                                  >
+                                                    {confirmingOntologyKey === `${project.id}:${projectOntology.id}:aliases` ? (
+                                                      <Loader2 className="spin" size={14} />
+                                                    ) : isAliasesConfirmed ? (
+                                                      <CheckCircle2 size={14} />
+                                                    ) : (
+                                                      <CircleAlert size={14} />
+                                                    )}
+                                                    {isAliasesConfirmed ? "Aliases confirmed" : "Confirm aliases"}
+                                                  </button>
+                                                </div>
+                                                <p>
+                                                  Instance: {projectOntology.schemaVersion} · source {projectOntology.source} · scan{" "}
+                                                  {projectOntology.scanVersionId ?? "none"} · run{" "}
+                                                  {projectOntology.semanticRunId ?? "none"}
+                                                </p>
+                                                <small>
+                                                  Evidence: {projectOntology.evidenceSummary.evidenceCount} · Sections:{" "}
+                                                  {projectOntology.evidenceSummary.sectionCount}
+                                                </small>
+                                                {(projectOntology.evidenceSummary.reviewItems ?? []).length > 0 ? (
+                                                  <div className="semantic-quality-list">
+                                                    {(projectOntology.evidenceSummary.reviewItems ?? []).map((item) => (
+                                                      <article className={`semantic-quality ${item.level}`} key={item.id}>
+                                                        <span>{getSemanticQualityLabel(item.level)}</span>
+                                                        <div>
+                                                          <strong>{item.title}</strong>
+                                                          <small>{item.message}</small>
+                                                        </div>
+                                                      </article>
+                                                    ))}
+                                                  </div>
+                                                ) : null}
+                                                {projectOntology.evidenceSummary.intentClusters.length > 0 ? (
+                                                  <div className="semantic-chip-list">
+                                                    {projectOntology.evidenceSummary.intentClusters.slice(0, 6).map((cluster) => (
+                                                      <span key={cluster.id}>
+                                                        {cluster.title} · {cluster.priority}
+                                                      </span>
+                                                    ))}
+                                                  </div>
+                                                ) : null}
+                                                {projectOntology.evidenceSummary.evidence.length > 0 ? (
+                                                  <div className="semantic-quality-list">
+                                                    {projectOntology.evidenceSummary.evidence.slice(0, 4).map((evidence) => (
+                                                      <article className="semantic-quality ok" key={evidence.id}>
+                                                        <span>{evidence.sourceType}</span>
+                                                        <div>
+                                                          <strong>{evidence.summary}</strong>
+                                                          <small>{evidence.ref}</small>
+                                                        </div>
+                                                      </article>
+                                                    ))}
+                                                  </div>
+                                                ) : null}
+                                              </details>
+                                            ) : null}
+                                          </>
+                                        ) : null}
+
                                         <div className="semantic-scope-grid">
                                           <div>
                                             <strong>Scope анализа</strong>
@@ -4244,7 +8150,7 @@ export function App() {
                                           <div className="semantic-page-plan-panel">
                                             <div>
                                               <strong>План посадочных</strong>
-                                              <small>Очередь страниц: что создать, что усилить, что отдать на Wordstat/SERP.</small>
+                                              <small>Очередь возможностей: что усилить, что проверить через Wordstat/SERP, что оставить гипотезой.</small>
                                             </div>
                                             {(semanticAnalysis.landingPagePlan ?? []).slice(0, 6).map((page) => (
                                               <article className={`semantic-page-plan-row ${page.action}`} key={page.path}>
@@ -4421,128 +8327,358 @@ export function App() {
                                             ))}
                                           </div>
                                         </div>
+                                          </div>
+                                        </details>
 
-                                        <div className="semantic-action-list">
-                                          <strong>Следующие действия</strong>
-                                          {semanticAnalysis.nextActions.map((action) => (
-                                            <p key={action}>{action}</p>
-                                          ))}
-                                        </div>
                                       </>
                                     ) : (
                                       <div className="empty-state semantic-empty">
                                         <Search size={18} />
-                                        Запусти semantic analysis: модуль прочитает HTML, JSON-контент, посчитает покрытие
-                                        NodeDC-онтологии, gaps, legacy-блокеры и стартовые сиды для Wordstat.
+                                        Запусти Context Review: модуль прочитает HTML, JSON-контент, meta и headings, чтобы
+                                        собрать смысл сайта, риски, gaps и seed phrases для проверки спроса.
                                       </div>
                                     )}
                                   </section>
                                 ) : null}
+                                {stageDecisionFrame ? (
+                                  <section className="stage-decision-frame">
+                                    <span>Решение этапа</span>
+                                    <div>
+                                      <strong>{stageDecisionFrame.question}</strong>
+                                      <small>{stageDecisionFrame.result}</small>
+                                    </div>
+                                    <p>{stageDecisionFrame.gate}</p>
+                                  </section>
+                                ) : null}
+
                                 {activeStageIndex === 4 ? (
                                   <section className="market-panel">
                                     <div className="market-heading">
                                       <div>
-                                        <strong>Market enrichment</strong>
-                                        <small>
-                                          Платформенный слой для Wordstat/SERP evidence. Пользователь не настраивает MCP и
-                                          внешние аккаунты вручную.
-                                        </small>
+                                        <strong>Рыночный спрос</strong>
+                                        <small>Какие темы сайта подтверждены внешним спросом, а какие пока остаются гипотезой.</small>
                                       </div>
                                       <button
                                         className="tiny-action primary"
-                                        disabled={!semanticAnalysis || isEnrichingMarket}
+                                        disabled={!semanticAnalysis || !activeContextReview || isEnrichingMarket}
                                         onClick={() => void handleMarketEnrichment(project)}
                                         type="button"
                                       >
                                         {isEnrichingMarket ? <Loader2 className="spin" size={14} /> : <Search size={14} />}
                                         {isEnrichingMarket
                                           ? "Запускаю..."
-                                          : marketEnrichment?.readiness.canCollectWordstat
+                                          : !activeContextReview
+                                            ? "Сначала Context Review"
+                                            : marketEnrichment?.readiness.canCollectWordstat
                                             ? "Собрать Wordstat"
                                             : "Проверить providers"}
                                       </button>
                                     </div>
 
+                                    {semanticAnalysis && !activeContextReview ? (
+                                      <div className="market-context-gate">
+                                        <div>
+                                          <strong>Перед рыночным спросом нужен Context Review</strong>
+                                          <small>
+                                            Сначала зафиксируй forbidden claims и normalization hints, чтобы Wordstat не получал сырые
+                                            внутренние формулировки сайта.
+                                          </small>
+                                        </div>
+                                        <button
+                                          className="tiny-action primary"
+                                          disabled={isReviewingContext}
+                                          onClick={() => void handleSeoContextReview(project)}
+                                          type="button"
+                                        >
+                                          {isReviewingContext ? <Loader2 className="spin" size={14} /> : <Save size={14} />}
+                                          {isReviewingContext ? "Сохраняю..." : "Сохранить Context Review"}
+                                        </button>
+                                      </div>
+                                    ) : null}
+
                                     {semanticAnalysis && marketEnrichment ? (
                                       <>
                                         <div className={`market-state-card ${marketEnrichment.state}`}>
                                           <div>
                                             <span>{getMarketStateLabel(marketEnrichment.state)}</span>
                                             <strong>
-                                              Seeds: {marketEnrichment.readiness.seedCount} · Briefs:{" "}
+                                              Темы: {marketEnrichment.readiness.seedCount} · Посадочные гипотезы:{" "}
                                               {marketEnrichment.readiness.briefCount}
                                             </strong>
                                             <small>
-                                              Provider connected: {marketEnrichment.readiness.configuredProviderCount}/
-                                              {marketEnrichment.providers.length} · user setup:{" "}
-                                              {marketEnrichment.readiness.userSetupRequired ? "required" : "not required"}
+                                              Проверено: {formatCount(marketEnrichment.wordstat.summary.collectedSeedCount)} · спрос:{" "}
+                                              {formatCount(getMarketSignalCount(marketEnrichment))} · пусто:{" "}
+                                              {formatCount(marketEnrichment.wordstat.summary.noSignalSeedCount ?? null)}
+                                            </small>
+                                            <small>
+                                              Контекст:{" "}
+                                              {marketEnrichment.projectOntologyVersion
+                                                ? `v${marketEnrichment.projectOntologyVersion.version} · ${getProjectOntologyApprovalLabel(
+                                                    marketEnrichment.projectOntologyVersion.approvalStatus
+                                                  )}`
+                                                : "not saved"}
                                             </small>
                                           </div>
                                           <p>
-                                            {marketEnrichment.state === "not_configured"
-                                              ? "Семантика готова к сбору рынка, но backend-провайдеры ещё не подключены."
-                                              : "Внешние evidence будут прикрепляться к seed, brief и page contract отдельно от deterministic-анализа."}
+                                            {!marketEnrichment.readiness.ontologyReadyForMarket
+                                              ? "Сначала нужно подтвердить контекст проекта, чтобы спрос не собирался по ошибочной семантике."
+                                              : marketEnrichment.state === "not_configured"
+                                              ? "Контекст готов, но сбор рыночного спроса ещё не настроен."
+                                              : "Спрос отделён от внутреннего анализа: видно, какие фразы подтверждены, а какие остаются гипотезой."}
                                           </p>
                                         </div>
 
+                                        {marketDecision ? (
+                                          <div className={`market-decision-board ${marketDecision.tone}`}>
+                                            <div className="market-decision-verdict">
+                                              <span>{marketDecision.label}</span>
+                                              <strong>{marketDecision.summary}</strong>
+                                              <p>{marketDecision.action}</p>
+                                            </div>
+                                            <div className="market-decision-metrics">
+                                              {getMarketEvidenceCards(marketEnrichment).map((item) => (
+                                                <article className={getChartToneClass(item.tone)} key={item.label}>
+                                                  <span>{item.label}</span>
+                                                  <strong>{formatCount(item.value)}</strong>
+                                                  <small>{item.detail}</small>
+                                                </article>
+                                              ))}
+                                            </div>
+                                          </div>
+                                        ) : null}
+
+                                        <div className="market-normalization-card">
+                                          <div>
+                                            <span>SEO-нормализация</span>
+                                            <strong>{marketEnrichment.normalization.summary}</strong>
+                                            <small>
+                                              Сырых seeds: {marketEnrichment.normalization.readiness.sourceSeedCount} · нормализовано:{" "}
+                                              {marketEnrichment.normalization.readiness.normalizedSeedCount} · intent groups:{" "}
+                                              {marketEnrichment.normalization.readiness.intentGroupCount} · review:{" "}
+                                              {marketEnrichment.normalization.readiness.needsHumanReviewCount}
+                                            </small>
+                                            <div className="market-normalization-stats">
+                                              <span>
+                                                {marketEnrichment.normalization.provider.mode === "codex_manual" ? "Codex" : "Fallback"}
+                                              </span>
+                                              <span>{marketEnrichment.normalization.analystReview.status}</span>
+                                              <span>Auto {marketEnrichment.normalization.readiness.autoApprovedCount}</span>
+                                              <span>Wordstat {marketEnrichment.normalization.readiness.wordstatApprovedCount}</span>
+                                              <span>SERP {marketEnrichment.normalization.readiness.serpApprovedCount}</span>
+                                              <span>Rejected {marketEnrichment.normalization.readiness.rejectedSeedCount}</span>
+                                              <span>
+                                                {marketEnrichment.normalization.modelTask ? "Model task ready" : "Model task waiting"}
+                                              </span>
+                                            </div>
+                                          </div>
+                                          <div className="market-normalization-groups">
+                                            {marketEnrichment.normalization.intentGroups.slice(0, 5).map((group) => (
+                                              <article key={group.id}>
+                                                <span>{getSeoIntentTypeLabel(group.intentType)}</span>
+                                                <strong>{group.title.replace(/^.*? · /, "")}</strong>
+                                                <small>{group.wordstatQueries.slice(0, 3).join(", ")}</small>
+                                              </article>
+                                            ))}
+                                          </div>
+                                          {marketEnrichment.normalization.rejectedSeeds.length > 0 ? (
+                                            <p>
+                                              Отсечено широких/мусорных seeds: {marketEnrichment.normalization.rejectedSeeds.length}.{" "}
+                                              {marketEnrichment.normalization.rejectedSeeds
+                                                .slice(0, 3)
+                                                .map((seed) => seed.phrase)
+                                                .join(", ")}
+                                            </p>
+                                          ) : null}
+                                        </div>
+
+                                        {normalizationReviewQueues ? (
+                                          <div className="market-normalization-review">
+                                            <SeoNormalizationReviewQueue
+                                              emptyLabel="Wordstat не готов"
+                                              seeds={normalizationReviewQueues.wordstat}
+                                              subtitle="approved market queries"
+                                              title="Можно проверять спрос"
+                                            />
+                                            <SeoNormalizationReviewQueue
+                                              emptyLabel="SERP не нужен"
+                                              seeds={normalizationReviewQueues.serp}
+                                              subtitle="типы страниц и конкуренты"
+                                              title="SERP / конкуренты"
+                                            />
+                                            <SeoNormalizationReviewQueue
+                                              emptyLabel="Нет спорных фраз"
+                                              seeds={normalizationReviewQueues.human}
+                                              subtitle="не отправлять без проверки"
+                                              title="Нужна проверка"
+                                            />
+                                            <SeoNormalizationReviewQueue
+                                              emptyLabel="Нет заблокированных"
+                                              seeds={normalizationReviewQueues.rejected}
+                                              subtitle="мусор или expansion branch"
+                                              title="Не отправлять"
+                                            />
+                                          </div>
+                                        ) : null}
+
+                                        <div className="seo-chart-grid seo-chart-grid-market">
+                                          <SeoShapeFunnelChart
+                                            items={getMarketFrequencyBars(marketEnrichment)}
+                                            subtitle="частотность approved Wordstat rows"
+                                            title="Сила спроса"
+                                          />
+                                          <SeoRingChart
+                                            centerLabel="approved"
+                                            centerValue={marketEnrichment.readiness.seedCount}
+                                            items={getMarketDemandComposition(marketEnrichment)}
+                                            subtitle="что случилось с approved queue"
+                                            title="Состав спроса"
+                                          />
+                                          <SeoRadarChart
+                                            items={getMarketReadinessRadar(marketEnrichment)}
+                                            subtitle="0-100, до SEO-плана"
+                                            title="Зрелость evidence"
+                                          />
+                                          <SeoScatterChart
+                                            emptyLabel="Точки появятся после Wordstat-сигналов или related rows."
+                                            points={getMarketOpportunityPoints(marketEnrichment)}
+                                            subtitle="частотность/related × приоритет"
+                                            title="Карта возможностей"
+                                            xLabel="спрос"
+                                            yLabel="приоритет"
+                                          />
+                                        </div>
+
                                         <div className="market-wordstat-card">
                                           <div>
-                                            <strong>Wordstat job</strong>
+                                            <strong>Сигналы approved queue</strong>
                                             <small>
                                               {marketEnrichment.wordstat.latestJob
-                                                ? `${marketEnrichment.wordstat.latestJob.status} · ${marketEnrichment.wordstat.latestJob.provider}/${marketEnrichment.wordstat.latestJob.mode} · ${marketEnrichment.wordstat.latestJob.requestedPhraseCount} seeds`
+                                                ? `${marketEnrichment.wordstat.latestJob.status} · ${marketEnrichment.wordstat.latestJob.requestedPhraseCount} фраз`
                                                 : "job ещё не создавался"}
                                             </small>
                                           </div>
                                           <div>
-                                            <span>{formatCount(marketEnrichment.wordstat.summary.collectedSeedCount)} checked</span>
+                                            <span>{formatCount(marketEnrichment.wordstat.summary.collectedSeedCount)} проверено</span>
                                             <span>
-                                              {formatCount(marketEnrichment.wordstat.summary.exactFrequencySeedCount ?? null)} exact
+                                              {formatCount(marketEnrichment.wordstat.summary.exactFrequencySeedCount ?? null)} точные
                                             </span>
                                             <span>
-                                              {formatCount(marketEnrichment.wordstat.summary.relatedOnlySeedCount ?? null)} related
+                                              {formatCount(marketEnrichment.wordstat.summary.relatedOnlySeedCount ?? null)} рядом
                                             </span>
                                             <span>
-                                              {formatCount(marketEnrichment.wordstat.summary.noSignalSeedCount ?? null)} empty
+                                              {formatCount(marketEnrichment.wordstat.summary.noSignalSeedCount ?? null)} пусто
                                             </span>
-                                            <span>{formatCount(marketEnrichment.wordstat.summary.resultCount)} rows</span>
-                                            <span>{formatCount(marketEnrichment.wordstat.summary.totalFrequency)} total</span>
+                                            <span>{formatCount(marketEnrichment.wordstat.summary.resultCount)} строк</span>
+                                            <span>{formatCount(marketEnrichment.wordstat.summary.totalFrequency)} суммарно</span>
                                           </div>
                                           {marketEnrichment.wordstat.latestJob?.errorMessage ? (
                                             <p>{marketEnrichment.wordstat.latestJob.errorMessage}</p>
                                           ) : null}
                                         </div>
 
-                                        <div className="market-provider-grid">
-                                          {marketEnrichment.providers.map((provider) => (
-                                            <article className={`market-provider ${provider.status}`} key={provider.id}>
-                                              <span>{getMarketProviderStatusLabel(provider.status)}</span>
+                                        {keywordCleaning ? (
+                                          <>
+                                            <div className="market-normalization-card keyword-cleaning-card">
                                               <div>
-                                                <strong>{provider.label}</strong>
-                                                <small>{provider.role}</small>
-                                                <p>{provider.message}</p>
+                                                <span>Keyword cleaning</span>
+                                                <strong>{keywordCleaning.summary}</strong>
+                                                <small>
+                                                  После Wordstat/SERP: что можно пустить в SEO-план, что оставить как backlog, что
+                                                  проверить и что выкинуть.
+                                                </small>
+                                                <div className="market-normalization-stats">
+                                                  <span>{keywordCleaning.provider.mode === "codex_manual" ? "Codex" : "Fallback"}</span>
+                                                  <span>{keywordCleaning.analystReview.status}</span>
+                                                  <span>Use {keywordCleaning.readiness.useCount}</span>
+                                                  <span>Support {keywordCleaning.readiness.supportCount}</span>
+                                                  <span>Article {keywordCleaning.readiness.articleCount}</span>
+                                                  <span>Risky {keywordCleaning.readiness.riskyCount}</span>
+                                                  <span>Trash {keywordCleaning.readiness.trashCount}</span>
+                                                </div>
                                               </div>
-                                            </article>
-                                          ))}
-                                        </div>
+                                              <button
+                                                className="tiny-action"
+                                                disabled={!keywordCleaning.modelTask || isRunningKeywordCleaningModelTask}
+                                                onClick={() => void handleSeoModelTaskRun(project, "seo.keyword_cleaning")}
+                                                type="button"
+                                              >
+                                                {isRunningKeywordCleaningModelTask ? (
+                                                  <Loader2 className="spin" size={14} />
+                                                ) : (
+                                                  <KeyRound size={14} />
+                                                )}
+                                                {isRunningKeywordCleaningModelTask ? "Готовлю..." : "Model route"}
+                                              </button>
+                                            </div>
+
+                                            <div className="market-normalization-review keyword-cleaning-review">
+                                              <SeoKeywordCleaningLane
+                                                emptyLabel="Нет фраз для SEO-плана"
+                                                items={[...keywordCleaning.lanes.use, ...keywordCleaning.lanes.support]}
+                                                subtitle="только это попадёт в keyword map"
+                                                title="В SEO-план"
+                                              />
+                                              <SeoKeywordCleaningLane
+                                                emptyLabel="Backlog пуст"
+                                                items={keywordCleaning.lanes.article}
+                                                subtitle="отдельные посадочные или контент"
+                                                title="Контент"
+                                              />
+                                              <SeoKeywordCleaningLane
+                                                emptyLabel="Нет спорных"
+                                                items={keywordCleaning.lanes.risky}
+                                                subtitle="нужна human/AI проверка"
+                                                title="Проверить"
+                                              />
+                                              <SeoKeywordCleaningLane
+                                                emptyLabel="Мусора нет"
+                                                items={keywordCleaning.lanes.trash}
+                                                subtitle="не пускать дальше"
+                                                title="Trash"
+                                              />
+                                            </div>
+
+                                            <div className="seo-chart-grid seo-chart-grid-keyword-cleaning">
+                                              <SeoShapeFunnelChart
+                                                items={getKeywordCleaningFunnelData(keywordCleaning)}
+                                                subtitle="санитарный слой после market evidence"
+                                                title="Очистка спроса"
+                                              />
+                                              <SeoScatterChart
+                                                emptyLabel="Точки появятся после Wordstat/SERP evidence."
+                                                points={getKeywordCleaningDemandPoints(keywordCleaning)}
+                                                subtitle="спрос × уверенность cleaning"
+                                                title="Что реально брать"
+                                                xLabel="спрос"
+                                                yLabel="уверенность"
+                                              />
+                                            </div>
+                                          </>
+                                        ) : null}
 
                                         <div className="market-columns">
                                           <section>
                                             <div>
-                                              <strong>Seed queue</strong>
-                                              <small>Фразы готовы к Wordstat, но не собраны без provider.</small>
+                                              <strong>Спрос по фразам</strong>
+                                              <small>Точные, смежные и пустые сигналы не смешиваются в одно решение.</small>
                                             </div>
                                             <div className="market-seed-list">
                                               {marketEnrichment.seedQueue.slice(0, 12).map((seed) => (
                                                 <div key={`${seed.clusterId}-${seed.phrase}`}>
-                                                  <span>{getMarketEvidenceStatusLabel(seed.evidenceStatus)}</span>
+                                                  <span>
+                                                    {seed.normalization
+                                                      ? getSeoMarketRoleLabel(seed.normalization.marketRole)
+                                                      : getMarketEvidenceStatusLabel(seed.evidenceStatus)}
+                                                  </span>
                                                   <strong>{seed.phrase}</strong>
                                                   <small>
                                                     {seed.frequency !== null
                                                       ? `${formatCount(seed.frequency)} · ${seed.frequencyGroup ?? "group n/a"} · related ${seed.relatedCount}`
                                                       : seed.relatedCount > 0
                                                         ? `${seed.clusterTitle} · related ${seed.relatedCount}`
-                                                        : seed.clusterTitle}
+                                                        : `${seed.clusterTitle}${
+                                                            seed.normalization?.needsHumanReview ? " · нужна проверка формулировки" : ""
+                                                          }`}
                                                   </small>
                                                 </div>
                                               ))}
@@ -4551,16 +8687,17 @@ export function App() {
 
                                           <section>
                                             <div>
-                                              <strong>Brief evidence</strong>
-                                              <small>Куда будут пришиты Wordstat/SERP/competitor evidence.</small>
+                                              <strong>Посадочные для проверки</strong>
+                                              <small>Куда может лечь подтвержденный спрос.</small>
                                             </div>
                                             <div className="market-brief-list">
                                               {marketEnrichment.briefEvidence.slice(0, 8).map((brief) => (
                                                 <div key={brief.path}>
-                                                  <span>{getMarketEvidenceStatusLabel(brief.evidenceStatus)}</span>
+                                                  <span>{brief.action}</span>
                                                   <strong>{brief.path}</strong>
                                                   <small>
-                                                    quality {brief.qualityScore ?? "n/a"} · {brief.missingEvidence.slice(0, 2).join("; ")}
+                                                    {brief.seedPhrases.slice(0, 3).join(", ") ||
+                                                      (brief.qualityScore !== null ? `качество ${brief.qualityScore}` : "ожидает проверки")}
                                                   </small>
                                                 </div>
                                               ))}
@@ -4570,7 +8707,7 @@ export function App() {
 
                                         {marketEnrichment.wordstat.topResults.length > 0 ? (
                                           <div className="market-next-actions market-wordstat-results">
-                                            <strong>Top Wordstat rows</strong>
+                                            <strong>Raw Wordstat rows</strong>
                                             <div>
                                               {marketEnrichment.wordstat.topResults.slice(0, 10).map((result) => (
                                                 <p key={`${result.sourcePhrase ?? "seed"}-${result.phrase}`}>
@@ -4582,24 +8719,1754 @@ export function App() {
                                           </div>
                                         ) : null}
 
-                                        <div className="market-next-actions">
-                                          <strong>Следующие platform actions</strong>
-                                          {marketEnrichment.nextActions.map((action) => (
-                                            <p key={action}>{action}</p>
-                                          ))}
-                                        </div>
                                       </>
                                     ) : semanticAnalysis ? (
                                       <div className="empty-state semantic-empty">
                                         <Search size={18} />
-                                        Market contract ещё не загружен. Нажми проверку providers, чтобы получить текущий
-                                        статус платформенных интеграций.
+                                        Контракт спроса ещё не загружен. Проверь providers, чтобы получить текущий статус
+                                        market evidence.
                                       </div>
                                     ) : (
                                       <div className="empty-state semantic-empty">
                                         <Search size={18} />
-                                        Сначала нужен semantic analysis: он подготовит seed candidates и SEO briefs для
-                                        market enrichment.
+                                        Сначала нужен semantic analysis: он подготовит темы, посадочные гипотезы и seed phrases
+                                        для проверки спроса.
+                                      </div>
+                                    )}
+                                  </section>
+                                ) : null}
+                                {activeStageIndex === 5 ? (
+                                  <section className="market-panel">
+                                    <div className="market-heading">
+                                      <div>
+                                        <strong>SEO-план страниц</strong>
+                                        <small>Что улучшать на страницах: фраза, поле, роль, лимит и причина решения.</small>
+                                      </div>
+                                      <button
+                                        className="tiny-action primary"
+                                        disabled={
+                                          !keywordMap ||
+                                          keywordMap.state !== "draft" ||
+                                          keywordMap.readiness.persistableItemCount === 0 ||
+                                          isPersistingKeywordMap
+                                        }
+                                        onClick={() => void handleApproveKeywordMapDecisions(project)}
+                                        type="button"
+                                      >
+                                        {isPersistingKeywordMap ? <Loader2 className="spin" size={14} /> : <KeyRound size={14} />}
+                                        {isPersistingKeywordMap ? "Фиксирую..." : "Зафиксировать"}
+                                      </button>
+                                    </div>
+
+                                    {keywordMap ? (
+                                      <>
+                                        {keywordPlanDecision ? (
+                                          <div className={`market-decision-board keyword-plan-board ${keywordPlanDecision.tone}`}>
+                                            <div className="market-decision-verdict">
+                                              <span>{keywordPlanDecision.label}</span>
+                                              <strong>{keywordPlanDecision.title}</strong>
+                                              <p>{keywordPlanDecision.summary}</p>
+                                              <p>{keywordPlanDecision.action}</p>
+                                              <small>
+                                                keyword-map.v1 · {getKeywordMapStateLabel(keywordMap.state)} · ontology{" "}
+                                                {keywordMap.projectOntologyVersion
+                                                  ? `v${keywordMap.projectOntologyVersion.version} / ${getProjectOntologyApprovalLabel(
+                                                      keywordMap.projectOntologyVersion.approvalStatus
+                                                    )}`
+                                                  : "не сохранена"}
+                                              </small>
+                                            </div>
+                                            <div className="market-decision-metrics">
+                                              {keywordPlanDecision.metrics.map((metric) => (
+                                                <article className={getChartToneClass(metric.tone)} key={metric.label}>
+                                                  <span>{metric.label}</span>
+                                                  <strong>{metric.value}</strong>
+                                                  <small>{metric.detail}</small>
+                                                </article>
+                                              ))}
+                                            </div>
+                                          </div>
+                                        ) : null}
+
+                                        <div className="market-wordstat-card keyword-cleaning-stage-summary">
+                                          <div>
+                                            <strong>Источник SEO-плана</strong>
+                                            <small>
+                                              {keywordMap.cleaning.schemaVersion} ·{" "}
+                                              {keywordMap.cleaning.providerMode === "codex_manual" ? "Codex" : "Fallback"} ·{" "}
+                                              {keywordMap.cleaning.analystStatus}
+                                            </small>
+                                          </div>
+                                          <div>
+                                            <span>use {keywordMap.cleaning.useCount}</span>
+                                            <span>support {keywordMap.cleaning.supportCount}</span>
+                                            <span>article {keywordMap.cleaning.articleCount}</span>
+                                            <span>risky {keywordMap.cleaning.riskyCount}</span>
+                                            <span>trash {keywordMap.cleaning.trashCount}</span>
+                                          </div>
+                                        </div>
+
+                                        <div className="seo-chart-grid seo-chart-grid-wide">
+                                          <SeoShapeFunnelChart
+                                            items={getKeywordFunnelData(keywordMap)}
+                                            subtitle="готовность SEO-плана к фиксации"
+                                            title="Готовность плана"
+                                          />
+                                          <SeoRingChart
+                                            centerLabel="фраз"
+                                            centerValue={keywordMap.readiness.seedCount}
+                                            items={getKeywordRoleBars(keywordMap)}
+                                            subtitle="главные, дополнительные, поддержка и проверка"
+                                            title="Роли фраз"
+                                          />
+                                          <SeoHeatmapChart
+                                            emptyLabel="Матрица появится после назначения фраз на страницы."
+                                            matrix={getKeywordRoleMatrix(keywordMap)}
+                                            subtitle="куда ложится нагрузка плана"
+                                            title="Страницы × роли"
+                                          />
+                                        </div>
+
+                                        {keywordMap.persisted.approvedDecisionCount > 0 ? (
+                                          <div className="market-wordstat-card">
+                                            <div>
+                                              <strong>Зафиксированный план</strong>
+                                              <small>
+                                                {keywordMap.persisted.latestApprovedAt
+                                                  ? formatDate(keywordMap.persisted.latestApprovedAt)
+                                                  : "timestamp n/a"}
+                                              </small>
+                                            </div>
+                                            <div>
+                                              <span>{keywordMap.persisted.approvedDecisionCount} решений</span>
+                                              <span>{keywordMap.persisted.mapItemCount} привязок</span>
+                                            </div>
+                                            <div className="market-seed-list">
+                                              {keywordMap.persisted.items.slice(0, 4).map((item) => (
+                                                <div key={`${item.decisionId}-${item.mapItemId ?? "decision"}`}>
+                                                  <span>{getKeywordMapRoleLabel(item.role)}</span>
+                                                  <strong>{item.phrase}</strong>
+                                                  <small>
+                                                    {item.targetPath ?? "без страницы"} · {item.workspaceSectionId ?? "секция не найдена"}
+                                                  </small>
+                                                </div>
+                                              ))}
+                                            </div>
+                                          </div>
+                                        ) : null}
+
+                                        <div className="market-next-actions">
+                                          <strong>Аналитическая база перед стратегией</strong>
+                                          <p>
+                                            Сайт не меняем. Этот этап должен доказать ценность анализа: контекст, спрос, evidence,
+                                            риски и понятные стратегические варианты.
+                                          </p>
+                                          <div className="keyword-next-action-list">
+                                            <p>
+                                              Уже есть: {keywordMap.persisted.approvedDecisionCount} подтверждённых решений,{" "}
+                                              {keywordMap.readiness.marketEvidenceCount} фраз с market evidence,{" "}
+                                              {keywordMap.cleaning.trashCount} мусорных фраз отфильтровано.
+                                            </p>
+                                            <p>
+                                              Не хватает: SERP/competitor evidence, Yandex Webmaster/Метрика/Search Console слой,
+                                              прогнозы трафика и понятная карта возможностей.
+                                            </p>
+                                            <p>
+                                              Следующий UX должен отвечать не “куда писать текст”, а “что мы поняли, где спрос,
+                                              где риск, какую стратегию выбрать”.
+                                            </p>
+                                          </div>
+                                        </div>
+
+                                        {keywordPagePlans.length > 0 ? (
+                                          <section className="keyword-page-plan">
+                                            <div className="keyword-page-plan-heading">
+                                              <div>
+                                                <strong>Что можно сделать по страницам</strong>
+                                                <small>
+                                                  Не таблица ключей, а карта решений: фиксировать, проверить или не пускать дальше.
+                                                </small>
+                                              </div>
+                                              <span>{keywordPagePlans.length} групп</span>
+                                            </div>
+                                            <div className="keyword-page-plan-grid">
+                                              {keywordPagePlans.map((pagePlan) => (
+                                                <article className={`keyword-page-plan-card ${pagePlan.status}`} key={pagePlan.key}>
+                                                  <div className="keyword-page-plan-head">
+                                                    <span>{pagePlan.statusLabel}</span>
+                                                    <div>
+                                                      <strong>{pagePlan.readableTarget}</strong>
+                                                      <small>
+                                                        {pagePlan.primaryItem
+                                                          ? `${pagePlan.primaryItem.clusterTitle} · ${getKeywordRoleFieldLabel(
+                                                              pagePlan.primaryItem.role
+                                                            )}`
+                                                          : "нет привязанного интента"}
+                                                      </small>
+                                                    </div>
+                                                  </div>
+                                                  <p>{pagePlan.action}</p>
+                                                  <div className="keyword-page-plan-stats">
+                                                    <span>главн. {pagePlan.counts.primary}</span>
+                                                    <span>доп. {pagePlan.counts.secondary}</span>
+                                                    <span>подд. {pagePlan.counts.support}</span>
+                                                    <span>review {pagePlan.reviewItems.length}</span>
+                                                  </div>
+                                                  <div className="keyword-page-phrase-list">
+                                                    {pagePlan.topItems.slice(0, 4).map((item) => (
+                                                      <div
+                                                        className={isKeywordPlanItemPersistable(item) ? "safe" : "review"}
+                                                        key={`${pagePlan.key}:${item.id}`}
+                                                      >
+                                                        <span>
+                                                          {getKeywordMapRoleLabel(item.role)} · {getKeywordRoleFieldLabel(item.role)}
+                                                        </span>
+                                                        <strong>{item.phrase}</strong>
+                                                        <small>
+                                                          {getMarketEvidenceStatusLabel(item.evidenceStatus)}
+                                                          {item.frequency !== null ? ` · ${formatCount(item.frequency)}` : ""} ·{" "}
+                                                          {item.reason}
+                                                        </small>
+                                                      </div>
+                                                    ))}
+                                                  </div>
+                                                </article>
+                                              ))}
+                                            </div>
+                                          </section>
+                                        ) : null}
+
+                                        <div className="market-columns keyword-plan-support-grid">
+                                          <section className="keyword-review-queue">
+                                            <div>
+                                              <strong>Что нельзя пускать в rewrite</strong>
+                                              <small>Фразы без безопасного exact evidence, page binding или с ролью validate.</small>
+                                            </div>
+                                            <div className="market-brief-list">
+                                              {keywordReviewItems.slice(0, 8).map((item) => (
+                                                <div key={`${item.id}:review`}>
+                                                  <span>{getMarketEvidenceStatusLabel(item.evidenceStatus)}</span>
+                                                  <strong>{item.phrase}</strong>
+                                                  <small>
+                                                    {item.targetPath ?? "без страницы"} · {getKeywordMapRoleLabel(item.role)} ·{" "}
+                                                    {item.reason}
+                                                  </small>
+                                                </div>
+                                              ))}
+                                              {keywordReviewItems.length === 0 ? (
+                                                <div>
+                                                  <span>ok</span>
+                                                  <strong>Review-очередь пуста</strong>
+                                                  <small>Все текущие назначения можно рассматривать как безопасные.</small>
+                                                </div>
+                                              ) : null}
+                                            </div>
+                                          </section>
+
+                                          <section className="keyword-next-actions">
+                                            <div>
+                                              <strong>Следующее действие</strong>
+                                              <small>Что нужно сделать перед stage 07 стратегией.</small>
+                                            </div>
+                                            <div className="keyword-next-action-list">
+                                              {keywordMap.nextActions.map((action) => (
+                                                <p key={action}>{action}</p>
+                                              ))}
+                                            </div>
+                                          </section>
+                                        </div>
+
+                                        {keywordMap.blockers.length > 0 ? (
+                                          <div className="market-next-actions">
+                                            <strong>Блокеры</strong>
+                                            {keywordMap.blockers.map((action) => (
+                                              <p key={action}>{action}</p>
+                                            ))}
+                                          </div>
+                                        ) : null}
+
+                                        {keywordMap.items.length > 0 ? (
+                                          <details className="semantic-dev-details keyword-raw-details">
+                                            <summary>
+                                              <span>DEV DETAILS</span>
+                                              <strong>Raw keyword-map items</strong>
+                                              <small>Сырой список фраз, ролей, страниц и evidence для проверки пайплайна.</small>
+                                            </summary>
+                                            <div className="semantic-dev-details-body keyword-raw-grid">
+                                              {keywordMap.items.map((item) => (
+                                                <div key={`${item.id}:raw`}>
+                                                  <span>{getKeywordMapRoleLabel(item.role)}</span>
+                                                  <strong>{item.phrase}</strong>
+                                                  <small>
+                                                    {item.targetPath ?? "без страницы"} · {item.clusterTitle} ·{" "}
+                                                    {getMarketEvidenceStatusLabel(item.evidenceStatus)}
+                                                    {item.frequency !== null ? ` · ${formatCount(item.frequency)}` : ""}
+                                                  </small>
+                                                </div>
+                                              ))}
+                                            </div>
+                                          </details>
+                                        ) : null}
+                                      </>
+                                    ) : (
+                                      <div className="empty-state semantic-empty">
+                                        <KeyRound size={18} />
+                                        Сначала нужны semantic analysis и рыночный спрос: SEO-план появится как draft поверх
+                                        reviewed ontology и evidence.
+                                      </div>
+                                    )}
+                                  </section>
+                                ) : null}
+                                {activeStageIndex === 6 ? (
+                                  <section className="market-panel">
+                                    <div className="market-heading">
+                                      <div>
+                                        <strong>SEO-стратегия</strong>
+                                        <small>
+                                          Read-only слой: доказываем возможности роста, риски и недостающие данные. Сайт на этом этапе не
+                                          меняем.
+                                        </small>
+                                      </div>
+                                      <GitBranch size={18} />
+                                    </div>
+
+                                    <div className={`market-decision-board ${yandexEvidence?.state === "ready" ? "tone-good" : "tone-warning"}`}>
+                                      <div className="market-decision-verdict">
+                                        <span>yandex-evidence.v1</span>
+                                        <strong>
+                                          {yandexEvidence
+                                            ? getYandexEvidenceStateLabel(yandexEvidence.state)
+                                            : "внешний evidence ещё не загружен"}
+                                        </strong>
+                                        <p>
+                                          Wordstat top/regions/dynamics и SERP конкурентов собираются отдельным read-only run. Это источник
+                                          фактов для стратегии, а не команда на rewrite.
+                                        </p>
+                                        <div className="model-provider-actions">
+                                          <button
+                                            className="tiny-action primary"
+                                            disabled={collectingYandexEvidenceProjectId === project.id}
+                                            onClick={() => void handleYandexEvidence(project)}
+                                            type="button"
+                                          >
+                                            {collectingYandexEvidenceProjectId === project.id ? (
+                                              <Loader2 className="spin" size={14} />
+                                            ) : (
+                                              <Search size={14} />
+                                            )}
+                                            {collectingYandexEvidenceProjectId === project.id ? "Собираю..." : "Собрать evidence"}
+                                          </button>
+                                          <button
+                                            className="tiny-action"
+                                            disabled={
+                                              yandexEvidence?.state !== "ready" ||
+                                              yandexEvidence.summary.serpDocCount === 0 ||
+                                              isRunningSerpInterpretationModelTask
+                                            }
+                                            onClick={() => void handleSeoModelTaskRun(project, "seo.serp_interpretation")}
+                                            type="button"
+                                          >
+                                            {isRunningSerpInterpretationModelTask ? (
+                                              <Loader2 className="spin" size={14} />
+                                            ) : (
+                                              <Plug size={14} />
+                                            )}
+                                            Task route
+                                          </button>
+                                          <button
+                                            className="tiny-action primary"
+                                            disabled={
+                                              yandexEvidence?.state !== "ready" ||
+                                              yandexEvidence.summary.serpDocCount === 0 ||
+                                              isInterpretingSerp
+                                            }
+                                            onClick={() => void handleSerpInterpretation(project)}
+                                            type="button"
+                                          >
+                                            {isInterpretingSerp ? <Loader2 className="spin" size={14} /> : <GitBranch size={14} />}
+                                            {isInterpretingSerp ? "Собираю..." : "Собрать interpretation"}
+                                          </button>
+                                        </div>
+                                      </div>
+                                      <div className="market-decision-metrics">
+                                        <article className={yandexEvidence?.summary.checkedPhraseCount ? "tone-good" : "tone-warning"}>
+                                          <span>Фразы</span>
+                                          <strong>{yandexEvidence?.summary.checkedPhraseCount ?? 0}</strong>
+                                          <small>проверено</small>
+                                        </article>
+                                        <article className={yandexEvidence?.summary.totalDemand ? "tone-good" : "tone-warning"}>
+                                          <span>Спрос</span>
+                                          <strong>{formatCount(yandexEvidence?.summary.totalDemand ?? 0)}</strong>
+                                          <small>Wordstat total</small>
+                                        </article>
+                                        <article className={yandexEvidence?.summary.serpDocCount ? "tone-good" : "tone-warning"}>
+                                          <span>SERP</span>
+                                          <strong>{yandexEvidence?.summary.serpDocCount ?? 0}</strong>
+                                          <small>docs</small>
+                                        </article>
+                                        <article className={yandexEvidence?.summary.competitorDomainCount ? "tone-good" : "tone-warning"}>
+                                          <span>Домены</span>
+                                          <strong>{yandexEvidence?.summary.competitorDomainCount ?? 0}</strong>
+                                          <small>competitors</small>
+                                        </article>
+                                      </div>
+                                    </div>
+
+                                    <div
+                                      className={`market-decision-board ${
+                                        serpInterpretation?.state === "ready" ? "tone-good" : "tone-warning"
+                                      }`}
+                                    >
+                                      <div className="market-decision-verdict">
+                                        <span>seo-serp-interpretation.v1</span>
+                                        <strong>
+                                          {serpInterpretation?.state === "ready"
+                                            ? "интерпретация собрана"
+                                            : "SERP facts ещё не интерпретированы"}
+                                        </strong>
+                                        <p>
+                                          {serpInterpretation?.state === "ready"
+                                            ? serpInterpretation.summary
+                                            : "Нужен отдельный слой, который объяснит target-fit, mismatch, конкурентные углы и риски. Сырые домены сами по себе не являются стратегией."}
+                                        </p>
+                                      </div>
+                                      <div className="market-decision-metrics">
+                                        <article className={serpInterpretation?.readiness.interpretedPhraseCount ? "tone-good" : "tone-warning"}>
+                                          <span>Фразы</span>
+                                          <strong>{serpInterpretation?.readiness.interpretedPhraseCount ?? 0}</strong>
+                                          <small>interpreted</small>
+                                        </article>
+                                        <article className={serpInterpretation?.readiness.mismatchCount ? "tone-warning" : "tone-good"}>
+                                          <span>Mismatch</span>
+                                          <strong>{serpInterpretation?.readiness.mismatchCount ?? 0}</strong>
+                                          <small>intent fit</small>
+                                        </article>
+                                        <article className={serpInterpretation?.readiness.competitorGapCount ? "tone-good" : "tone-warning"}>
+                                          <span>Gaps</span>
+                                          <strong>{serpInterpretation?.readiness.competitorGapCount ?? 0}</strong>
+                                          <small>competitors</small>
+                                        </article>
+                                        <article className={serpInterpretation?.readiness.riskCount ? "tone-warning" : "tone-good"}>
+                                          <span>Риски</span>
+                                          <strong>{serpInterpretation?.readiness.riskCount ?? 0}</strong>
+                                          <small>до approval</small>
+                                        </article>
+                                      </div>
+                                    </div>
+
+                                    {seoStrategy ? (
+                                      <>
+	                                        <div className={`market-state-card ${getSeoStrategyStateClass(seoStrategy.state)}`}>
+	                                          <div>
+	                                            <span>{getSeoStrategyStateLabel(seoStrategy.state)}</span>
+	                                            <strong>{seoStrategy.verdict.title}</strong>
+                                            <small>
+                                              Confidence: {getSeoStrategyConfidenceLabel(seoStrategy.verdict.confidence)} · score{" "}
+                                              {seoStrategy.readiness.strategyConfidenceScore}/100 ·{" "}
+                                              {seoStrategy.projectOntologyVersion?.id
+                                                ? `ontology ${seoStrategy.projectOntologyVersion.id.slice(0, 8)}`
+                                                : "ontology не подтверждена"}
+                                            </small>
+                                            <small>Главное ограничение: {seoStrategy.verdict.primaryConstraint}</small>
+                                          </div>
+	                                          <p>{seoStrategy.verdict.summary}</p>
+	                                        </div>
+
+		                                        <div className="market-decision-board tone-warning">
+		                                          <div className="market-decision-verdict">
+		                                            <span>site-maturity.v1</span>
+		                                            <strong>{getSeoMaturityPhaseLabel(seoStrategy.siteMaturity.phase)}</strong>
+		                                            <p>{seoStrategy.siteMaturity.reason}</p>
+	                                          </div>
+	                                          <div className="market-decision-metrics">
+	                                            <article className={seoStrategy.siteMaturity.signals.hasIndexEvidence ? "tone-good" : "tone-warning"}>
+	                                              <span>Индекс</span>
+	                                              <strong>{seoStrategy.siteMaturity.signals.hasIndexEvidence ? "есть" : "нет"}</strong>
+	                                              <small>site evidence</small>
+	                                            </article>
+	                                            <article className={seoStrategy.siteMaturity.signals.hasTractionEvidence ? "tone-good" : "tone-warning"}>
+	                                              <span>Traction</span>
+	                                              <strong>{seoStrategy.siteMaturity.signals.hasTractionEvidence ? "есть" : "нет"}</strong>
+	                                              <small>impressions/clicks</small>
+	                                            </article>
+	                                            <article className={seoStrategy.siteMaturity.signals.hasSerpInterpretation ? "tone-good" : "tone-warning"}>
+	                                              <span>SERP</span>
+	                                              <strong>{seoStrategy.siteMaturity.signals.hasSerpInterpretation ? "OK" : "нет"}</strong>
+	                                              <small>market view</small>
+	                                            </article>
+	                                            <article className={seoStrategy.siteMaturity.signals.hasAuthorityEvidence ? "tone-good" : "tone-warning"}>
+	                                              <span>Authority</span>
+	                                              <strong>{seoStrategy.siteMaturity.signals.hasAuthorityEvidence ? "есть" : "нет"}</strong>
+	                                              <small>head terms gate</small>
+		                                            </article>
+		                                          </div>
+		                                        </div>
+
+		                                        <section className="strategy-phase-selector">
+		                                          <div className="strategy-phase-heading">
+		                                            <div>
+		                                              <span>выбор стартовой стратегии</span>
+		                                              <strong>
+		                                                {seoStrategy.siteMaturity.phase === "bootstrap_indexing"
+		                                                  ? "Сайт выглядит как нулевой: начинаем с индексации и long-tail"
+		                                                  : `Рекомендован старт с фазы ${getSeoMaturityPhaseLabel(seoStrategy.siteMaturity.phase)}`}
+		                                              </strong>
+		                                              <small>
+		                                                Можно открыть любую фазу и понять, что она даст, но immediate route должен соответствовать
+		                                                доказанной зрелости сайта.
+		                                              </small>
+		                                            </div>
+		                                          </div>
+		                                          <div className="strategy-phase-tabs" role="tablist" aria-label="Фазы SEO-стратегии">
+		                                            {seoStrategy.phasePlan.map((phase) => {
+		                                              const isSelected = selectedStrategyPhaseId === phase.phase;
+		                                              const isCurrent = seoStrategy.siteMaturity.phase === phase.phase;
+
+		                                              return (
+		                                                <button
+		                                                  aria-selected={isSelected}
+		                                                  className={`${isSelected ? "active" : ""} ${isCurrent ? "recommended" : ""}`.trim()}
+		                                                  key={phase.phase}
+		                                                  onClick={() =>
+		                                                    setSelectedStrategyPhaseIds((currentPhaseIds) => ({
+		                                                      ...currentPhaseIds,
+		                                                      [project.id]: phase.phase
+		                                                    }))
+		                                                  }
+		                                                  role="tab"
+		                                                  type="button"
+		                                                >
+		                                                  <span>{getSeoPhaseStatusLabel(phase.status)}</span>
+		                                                  <strong>{phase.title}</strong>
+		                                                  <small>{isCurrent ? "рекомендовано сейчас" : "посмотреть маршрут"}</small>
+		                                                </button>
+		                                              );
+		                                            })}
+		                                          </div>
+		                                          {selectedStrategyPhase ? (
+		                                            <div className="strategy-phase-detail">
+		                                              <div>
+		                                                <span>{getSeoPhaseStatusLabel(selectedStrategyPhase.status)}</span>
+		                                                <strong>{selectedStrategyPhase.title}</strong>
+		                                                <p>{selectedStrategyPhase.goal}</p>
+		                                              </div>
+		                                              <div className="strategy-phase-detail-grid">
+		                                                <article>
+		                                                  <span>можно делать</span>
+		                                                  {selectedStrategyPhase.allowedTargets.slice(0, 4).map((target) => (
+		                                                    <strong key={`allowed:${selectedStrategyPhase.phase}:${target}`}>{target}</strong>
+		                                                  ))}
+		                                                </article>
+		                                                <article>
+		                                                  <span>не сейчас</span>
+		                                                  {selectedStrategyPhase.deferredTargets.slice(0, 4).map((target) => (
+		                                                    <strong key={`deferred:${selectedStrategyPhase.phase}:${target}`}>{target}</strong>
+		                                                  ))}
+		                                                </article>
+		                                                <article>
+		                                                  <span>переход дальше</span>
+		                                                  {selectedStrategyPhase.promotionSignals.slice(0, 4).map((signal) => (
+		                                                    <strong key={`signal:${selectedStrategyPhase.phase}:${signal}`}>{signal}</strong>
+		                                                  ))}
+		                                                </article>
+		                                              </div>
+		                                              <p>{selectedStrategyPhase.risk}</p>
+		                                            </div>
+		                                          ) : null}
+		                                        </section>
+
+		                                        <div className="market-columns">
+	                                          <section>
+	                                            <div>
+	                                              <strong>SEO runway</strong>
+	                                              <small>Фазы роста: что можно сейчас и что откроется после сигналов.</small>
+	                                            </div>
+	                                            <div className="market-brief-list">
+	                                              {seoStrategy.phasePlan.map((phase) => (
+	                                                <div key={phase.phase}>
+	                                                  <span className={phase.status === "current" ? "collected" : "ready_for_collection"}>
+	                                                    {getSeoPhaseStatusLabel(phase.status)}
+	                                                  </span>
+	                                                  <strong>{phase.title}</strong>
+	                                                  <small>{phase.goal}</small>
+	                                                  <small>Можно: {phase.allowedTargets.slice(0, 2).join(" · ")}</small>
+	                                                  <small>Не сейчас: {phase.deferredTargets.slice(0, 2).join(" · ")}</small>
+	                                                </div>
+	                                              ))}
+	                                            </div>
+	                                          </section>
+
+	                                          <section>
+	                                            <div>
+	                                              <strong>Переход в следующую фазу</strong>
+	                                              <small>Какие сигналы нужны, чтобы повышать конкуренцию ключей.</small>
+	                                            </div>
+	                                            <div className="market-brief-list">
+	                                              {seoStrategy.siteMaturity.promotionSignals.map((signal) => (
+	                                                <div key={`promotion:${signal}`}>
+	                                                  <span>signal</span>
+	                                                  <strong>{signal}</strong>
+	                                                </div>
+	                                              ))}
+	                                              {seoStrategy.siteMaturity.guardrails.map((guardrail) => (
+	                                                <div key={`guardrail:${guardrail}`}>
+	                                                  <span className="not_configured">guardrail</span>
+	                                                  <strong>{guardrail}</strong>
+	                                                </div>
+	                                              ))}
+	                                            </div>
+	                                          </section>
+	                                        </div>
+
+	                                        <div className={`market-decision-board ${getChartToneClass(getStrategyTone(seoStrategy.readiness.strategyConfidenceScore))}`}>
+                                          <div className="market-decision-verdict">
+                                            <span>strategy.v1</span>
+                                            <strong>Понятная база перед любыми изменениями сайта</strong>
+                                            <p>
+                                              Сейчас ценность этапа в том, чтобы показать, где спрос уже подтверждён, где аналитика слабая и
+                                              какие сервисы надо подключить для зрелого решения.
+                                            </p>
+                                            <div className="model-provider-actions">
+                                              <button
+                                                className="tiny-action"
+                                                disabled={!canPrepareStrategySynthesis || isRunningStrategySynthesisModelTask}
+                                                onClick={() => void handleSeoModelTaskRun(project, "seo.strategy_synthesis")}
+                                                type="button"
+                                              >
+                                                {isRunningStrategySynthesisModelTask ? (
+                                                  <Loader2 className="spin" size={14} />
+                                                ) : (
+                                                  <Plug size={14} />
+                                                )}
+                                                Task route
+                                              </button>
+                                              <button
+                                                className="tiny-action primary"
+                                                disabled={!canPrepareStrategySynthesis || isSynthesizingStrategy}
+                                                onClick={() => void handleStrategySynthesis(project)}
+                                                type="button"
+                                              >
+                                                {isSynthesizingStrategy ? <Loader2 className="spin" size={14} /> : <GitBranch size={14} />}
+                                                {isSynthesizingStrategy ? "Собираю..." : "Собрать synthesis"}
+                                              </button>
+                                            </div>
+                                          </div>
+                                          <div className="market-decision-metrics">
+                                            <article className={seoStrategy.readiness.contextReady ? "tone-good" : "tone-warning"}>
+                                              <span>Контекст</span>
+                                              <strong>{seoStrategy.readiness.contextReady ? "OK" : "Review"}</strong>
+                                              <small>{seoStrategy.evidence.context.status}</small>
+                                            </article>
+                                            <article className={seoStrategy.readiness.opportunityCount > 0 ? "tone-good" : "tone-warning"}>
+                                              <span>Возможности</span>
+                                              <strong>{seoStrategy.readiness.opportunityCount}</strong>
+                                              <small>opportunity groups</small>
+                                            </article>
+                                            <article className={seoStrategy.readiness.evidenceGapCount > 0 ? "tone-warning" : "tone-good"}>
+                                              <span>Gaps</span>
+                                              <strong>{seoStrategy.readiness.evidenceGapCount}</strong>
+                                              <small>данных не хватает</small>
+                                            </article>
+                                            <article className={seoStrategy.readiness.riskCount > 0 ? "tone-warning" : "tone-good"}>
+                                              <span>Риски</span>
+                                              <strong>{seoStrategy.readiness.riskCount}</strong>
+                                              <small>до approval</small>
+                                            </article>
+                                          </div>
+                                        </div>
+
+                                        <div className="seo-chart-grid seo-chart-grid-wide">
+                                          <SeoBarChart
+                                            items={getSeoStrategyReadinessBars(seoStrategy)}
+                                            subtitle="что уже держит стратегию"
+                                            title="Readiness"
+                                          />
+                                          <SeoShapeFunnelChart
+                                            items={getSeoStrategyDemandBars(seoStrategy)}
+                                            subtitle="точный спрос, полезное, спорное, шум"
+                                            title="Спрос"
+                                          />
+                                          <SeoBarChart
+                                            items={getSeoStrategyProviderBars(seoStrategy)}
+                                            subtitle="Wordstat уже есть, SERP/Webmaster/AI ещё нужны"
+                                            title="Сервисы"
+                                          />
+                                        </div>
+
+                                        <div
+                                          className={`market-decision-board ${
+                                            strategySynthesis?.state === "ready"
+                                              ? getChartToneClass(getStrategyTone(strategySynthesis.readiness.confidenceScore))
+                                              : "tone-warning"
+                                          }`}
+                                        >
+                                          <div className="market-decision-verdict">
+                                            <span>seo-strategy-synthesis.v1</span>
+                                            <strong>
+                                              {strategySynthesis
+                                                ? getStrategySynthesisStateLabel(strategySynthesis.state)
+                                                : "strategy synthesis не собран"}
+                                            </strong>
+                                            <p>
+                                              {strategySynthesis?.state === "ready"
+                                                ? strategySynthesis.summary
+                                                : "Нужен верхний AI/MCP слой, который превратит evidence, SERP и keyword map в понятные варианты решения, риски и следующий аналитический шаг."}
+                                            </p>
+                                          </div>
+                                          <div className="market-decision-metrics">
+                                            {(strategySynthesis
+                                              ? getStrategySynthesisMetrics(strategySynthesis)
+                                              : [
+                                                  {
+                                                    detail: "0-100, по evidence stack",
+                                                    label: "Score",
+                                                    tone: "warning" as const,
+                                                    value: 0
+                                                  },
+                                                  {
+                                                    detail: "варианты решения",
+                                                    label: "Опции",
+                                                    tone: "warning" as const,
+                                                    value: 0
+                                                  },
+                                                  {
+                                                    detail: "чего не хватает",
+                                                    label: "Gaps",
+                                                    tone: "warning" as const,
+                                                    value: seoStrategy.readiness.evidenceGapCount
+                                                  },
+                                                  {
+                                                    detail: "риск-позиция",
+                                                    label: "Риски",
+                                                    tone: "warning" as const,
+                                                    value: seoStrategy.readiness.riskCount
+                                                  }
+                                                ]).map((metric) => (
+                                              <article className={getChartToneClass(metric.tone)} key={`synthesis-metric:${metric.label}`}>
+                                                <span>{metric.label}</span>
+                                                <strong>{metric.value}</strong>
+                                                <small>{metric.detail}</small>
+                                              </article>
+                                            ))}
+                                          </div>
+                                        </div>
+
+                                        {strategySynthesis?.state === "ready" ? (
+                                          <>
+	                                            <section className="market-next-actions">
+	                                              <strong>{strategySynthesis.executiveSummary.title}</strong>
+	                                              <p>{strategySynthesis.executiveSummary.verdict}</p>
+	                                              <p>{strategySynthesis.executiveSummary.whyNow}</p>
+	                                              <p>Ограничение: {strategySynthesis.executiveSummary.primaryConstraint}</p>
+	                                            </section>
+
+	                                            <div className="market-columns">
+	                                              <section>
+	                                                <div>
+	                                                  <strong>{strategySynthesis.phaseDecision.title}</strong>
+	                                                  <small>{getSeoMaturityPhaseLabel(strategySynthesis.phaseDecision.currentPhase)}</small>
+	                                                </div>
+	                                                <div className="market-brief-list">
+	                                                  <div>
+	                                                    <span className="collected">phase</span>
+	                                                    <strong>{strategySynthesis.phaseDecision.summary}</strong>
+	                                                  </div>
+	                                                  {strategySynthesis.phaseDecision.allowedNow.slice(0, 4).map((action) => (
+	                                                    <div key={`phase-now:${action}`}>
+	                                                      <span>now</span>
+	                                                      <strong>{action}</strong>
+	                                                    </div>
+	                                                  ))}
+	                                                </div>
+	                                              </section>
+
+	                                              <section>
+	                                                <div>
+	                                                  <strong>Не сейчас</strong>
+	                                                  <small>Что нельзя выдавать как immediate route до зрелости сайта.</small>
+	                                                </div>
+	                                                <div className="market-brief-list">
+	                                                  {strategySynthesis.phaseDecision.prepareNext.slice(0, 3).map((action) => (
+	                                                    <div key={`phase-prepare:${action}`}>
+	                                                      <span>prepare</span>
+	                                                      <strong>{action}</strong>
+	                                                    </div>
+	                                                  ))}
+	                                                  {strategySynthesis.phaseDecision.hold.slice(0, 5).map((action) => (
+	                                                    <div key={`phase-hold:${action}`}>
+	                                                      <span className="not_configured">hold</span>
+	                                                      <strong>{action}</strong>
+	                                                    </div>
+	                                                  ))}
+	                                                </div>
+	                                              </section>
+	                                            </div>
+
+	                                            <div className="market-columns">
+                                              <section>
+                                                <div>
+                                                  <strong>Рекомендованный путь</strong>
+                                                  <small>
+                                                    Confidence {getSeoStrategyConfidenceLabel(strategySynthesis.recommendedPath.confidence)} ·
+                                                    impact {getSeoStrategyPriorityLabel(strategySynthesis.recommendedPath.expectedImpact)}
+                                                  </small>
+                                                </div>
+                                                <div className="market-brief-list">
+                                                  <div>
+                                                    <span className="collected">
+                                                      {getSeoStrategyPriorityLabel(strategySynthesis.recommendedPath.priority)}
+                                                    </span>
+                                                    <strong>{strategySynthesis.recommendedPath.title}</strong>
+                                                    <small>{strategySynthesis.recommendedPath.rationale}</small>
+                                                  </div>
+                                                  {strategySynthesis.recommendedPath.doNow.slice(0, 4).map((action) => (
+                                                    <div key={`synthesis-now:${action}`}>
+                                                      <span>now</span>
+                                                      <strong>{action}</strong>
+                                                    </div>
+                                                  ))}
+                                                  {strategySynthesis.recommendedPath.hold.slice(0, 3).map((action) => (
+                                                    <div key={`synthesis-hold:${action}`}>
+                                                      <span className="not_configured">hold</span>
+                                                      <strong>{action}</strong>
+                                                    </div>
+                                                  ))}
+                                                </div>
+                                              </section>
+
+                                              <section>
+                                                <div>
+                                                  <strong>Варианты решения</strong>
+                                                  <small>Что пользователь должен выбрать или отправить на дополнительный анализ.</small>
+                                                </div>
+                                                <div className="market-brief-list">
+                                                  {strategySynthesis.decisionOptions.slice(0, 4).map((option) => (
+                                                    <div key={option.id}>
+                                                      <span className={option.priority === "high" ? "collected" : "ready_for_collection"}>
+                                                        {getStrategySynthesisScenarioLabel(option.scenario)}
+                                                      </span>
+                                                      <strong>{option.title}</strong>
+                                                      <small>
+                                                        impact {getSeoStrategyPriorityLabel(option.expectedImpact)} · effort{" "}
+                                                        {getSeoStrategyPriorityLabel(option.effort)} · confidence{" "}
+                                                        {getSeoStrategyConfidenceLabel(option.confidence)}
+                                                      </small>
+                                                      <small>{option.rationale}</small>
+                                                      <small>Дальше: {option.nextStep}</small>
+                                                    </div>
+                                                  ))}
+                                                </div>
+                                              </section>
+                                            </div>
+
+                                            <div className="market-columns">
+                                              <section>
+                                                <div>
+                                                  <strong>Что уже доказано</strong>
+                                                  <small>Краткая evidence narrative, без выдуманного спроса и домыслов.</small>
+                                                </div>
+                                                <div className="market-seed-list">
+                                                  {strategySynthesis.evidenceNarrative.slice(0, 6).map((evidence) => (
+                                                    <div key={evidence.id}>
+                                                      <span>{getSeoStrategyConfidenceLabel(evidence.confidence)}</span>
+                                                      <strong>{evidence.title}</strong>
+                                                      <small>{evidence.whatWeKnow}</small>
+                                                      <small>{evidence.whyItMatters}</small>
+                                                    </div>
+                                                  ))}
+                                                </div>
+                                              </section>
+
+                                              <section>
+                                                <div>
+                                                  <strong>Что блокирует уверенное решение</strong>
+                                                  <small>Недостающие данные и действия, которые нельзя заменить модельной фантазией.</small>
+                                                </div>
+                                                <div className="market-brief-list">
+                                                  {strategySynthesis.dataGaps.slice(0, 6).map((gap) => (
+                                                    <div key={gap.id}>
+                                                      <span className={gap.priority === "high" ? "not_configured" : "ready_for_collection"}>
+                                                        {getStrategySynthesisOwnerLabel(gap.owner)}
+                                                      </span>
+                                                      <strong>{gap.title}</strong>
+                                                      <small>{gap.whyItBlocks}</small>
+                                                      <small>Дальше: {gap.nextStep}</small>
+                                                    </div>
+                                                  ))}
+                                                  {strategySynthesis.blockedActions.slice(0, 4).map((action) => (
+                                                    <div key={`blocked:${action}`}>
+                                                      <span className="not_configured">blocked</span>
+                                                      <strong>{action}</strong>
+                                                    </div>
+                                                  ))}
+                                                </div>
+                                              </section>
+                                            </div>
+                                          </>
+                                        ) : null}
+
+                                        <div className="market-columns">
+                                          <section>
+                                            <div>
+                                              <strong>Yandex evidence</strong>
+                                              <small>Факты внешнего рынка: спрос, SERP intent, конкуренты и сезонность.</small>
+                                            </div>
+                                            <div className="market-seed-list">
+                                              {yandexEvidence?.phrases.slice(0, 6).map((phrase) => (
+                                                <div key={`yandex:${phrase.phrase}`}>
+                                                  <span className={phrase.status === "ok" ? "collected" : "ready_for_collection"}>
+                                                    {getYandexEvidenceIntentLabel(phrase.interpretation.serpIntent)}
+                                                  </span>
+                                                  <strong>{phrase.phrase}</strong>
+                                                  <small>
+                                                    {formatCount(phrase.wordstat.totalCount ?? 0)} спрос · difficulty{" "}
+                                                    {phrase.interpretation.difficultyScore}/100 ·{" "}
+                                                    {getYandexEvidenceSeasonalityLabel(phrase.interpretation.seasonality)}
+                                                  </small>
+                                                  <small>{phrase.serp.topDomains.slice(0, 4).join(" · ") || "SERP domains не собраны"}</small>
+                                                </div>
+                                              ))}
+                                              {!yandexEvidence || yandexEvidence.phrases.length === 0 ? (
+                                                <div>
+                                                  <span>empty</span>
+                                                  <strong>Yandex evidence ещё не собран</strong>
+                                                  <small>Запусти сбор после Wordstat/keyword-map, чтобы стратегия увидела рынок.</small>
+                                                </div>
+                                              ) : null}
+                                            </div>
+                                          </section>
+
+                                          <section>
+                                            <div>
+                                              <strong>Конкурентные домены</strong>
+                                              <small>Кто уже занимает выдачу по проверенным фразам.</small>
+                                            </div>
+                                            <div className="market-brief-list">
+                                              {yandexEvidence?.competitorDomains.slice(0, 8).map((domain) => (
+                                                <div key={`domain:${domain.domain}`}>
+                                                  <span className="collected">{domain.count}</span>
+                                                  <strong>{domain.domain}</strong>
+                                                  <small>{domain.sampleTitle}</small>
+                                                </div>
+                                              ))}
+                                              {!yandexEvidence || yandexEvidence.competitorDomains.length === 0 ? (
+                                                <div>
+                                                  <span>empty</span>
+                                                  <strong>Конкуренты ещё не сняты</strong>
+                                                  <small>Нужен WebSearch evidence run.</small>
+                                                </div>
+                                              ) : null}
+                                            </div>
+                                          </section>
+                                        </div>
+
+                                        {serpInterpretation?.state === "ready" ? (
+                                          <div className="market-columns">
+                                            <section>
+                                              <div>
+                                                <strong>SERP interpretation</strong>
+                                                <small>Интент выдачи, fit с целевой страницей и роль фразы в стратегии.</small>
+                                              </div>
+                                              <div className="market-seed-list">
+                                                {serpInterpretation.phraseInterpretations.slice(0, 6).map((phrase) => (
+                                                  <div key={`serp-phrase:${phrase.phrase}`}>
+                                                    <span
+                                                      className={
+                                                        phrase.targetFit === "mismatch"
+                                                          ? "not_configured"
+                                                          : phrase.targetFit === "strong_fit"
+                                                            ? "collected"
+                                                            : "ready_for_collection"
+                                                      }
+                                                    >
+                                                      {getSerpTargetFitLabel(phrase.targetFit)}
+                                                    </span>
+                                                    <strong>{phrase.phrase}</strong>
+                                                    <small>
+                                                      {getYandexEvidenceIntentLabel(phrase.intent)} ·{" "}
+                                                      {getSerpRecommendedRoleLabel(phrase.recommendedRole)} · confidence{" "}
+                                                      {getSeoStrategyConfidenceLabel(phrase.confidence)}
+                                                    </small>
+                                                    <small>{phrase.opportunity}</small>
+                                                    {phrase.risk ? <small>{phrase.risk}</small> : null}
+                                                  </div>
+                                                ))}
+                                              </div>
+                                            </section>
+
+                                            <section>
+                                              <div>
+                                                <strong>Competitor angles</strong>
+                                                <small>Не список доменов, а гипотезы: чем занята выдача.</small>
+                                              </div>
+                                              <div className="market-brief-list">
+                                                {serpInterpretation.competitorGaps.slice(0, 6).map((gap) => (
+                                                  <div key={`serp-gap:${gap.domain}`}>
+                                                    <span className="collected">{gap.count}</span>
+                                                    <strong>{gap.domain}</strong>
+                                                    <small>{gap.observedAngle}</small>
+                                                    <small>{gap.strategyImplication}</small>
+                                                  </div>
+                                                ))}
+                                              </div>
+                                            </section>
+                                          </div>
+                                        ) : null}
+
+                                        <div className="market-columns">
+                                          <section>
+                                            <div>
+                                              <strong>Возможности роста</strong>
+                                              <small>Не “слова ради слов”, а группы, где есть спрос, страница и следующий evidence.</small>
+                                            </div>
+                                            <div className="market-seed-list">
+	                                              {seoStrategy.opportunities.slice(0, 8).map((opportunity) => (
+	                                                <div key={opportunity.id}>
+	                                                  <span
+	                                                    className={
+	                                                      opportunity.timing.action === "do_now"
+	                                                        ? "collected"
+	                                                        : opportunity.timing.action === "defer"
+	                                                          ? "not_configured"
+	                                                          : "ready_for_collection"
+	                                                    }
+	                                                  >
+	                                                    {getSeoOpportunityActionLabel(opportunity.timing.action)}
+	                                                  </span>
+	                                                  <strong>{opportunity.title}</strong>
+	                                                  <small>
+	                                                    {opportunity.targetPath ?? "страница не выбрана"} ·{" "}
+	                                                    {formatCount(opportunity.demand.totalFrequency)} спрос · confidence{" "}
+	                                                    {getSeoStrategyConfidenceLabel(opportunity.confidence)} ·{" "}
+	                                                    {getSeoCompetitionTierLabel(opportunity.competitionTier)}
+	                                                  </small>
+	                                                  <small>{opportunity.whyItMatters}</small>
+	                                                  <small>{opportunity.timing.reason}</small>
+	                                                  <small>{opportunity.recommendation}</small>
+	                                                </div>
+	                                              ))}
+                                              {seoStrategy.opportunities.length === 0 ? (
+                                                <div>
+                                                  <span>empty</span>
+                                                  <strong>Возможности ещё не доказаны</strong>
+                                                  <small>Нужны market evidence, SERP и нормализация фраз.</small>
+                                                </div>
+                                              ) : null}
+                                            </div>
+                                          </section>
+
+                                          <section>
+                                            <div>
+                                              <strong>Evidence gaps</strong>
+                                              <small>Что мешает назвать стратегию зрелой и полезной.</small>
+                                            </div>
+                                            <div className="market-brief-list">
+                                              {seoStrategy.missingEvidence.slice(0, 8).map((evidence) => (
+                                                <div key={evidence.id}>
+                                                  <span className={evidence.priority === "high" ? "not_configured" : "ready_for_collection"}>
+                                                    {getSeoStrategyOwnerLabel(evidence.owner)}
+                                                  </span>
+                                                  <strong>{evidence.title}</strong>
+                                                  <small>{evidence.impact}</small>
+                                                </div>
+                                              ))}
+                                              {seoStrategy.missingEvidence.length === 0 ? (
+                                                <div>
+                                                  <span className="collected">OK</span>
+                                                  <strong>Критичных gaps нет</strong>
+                                                  <small>Можно готовить human strategy approval.</small>
+                                                </div>
+                                              ) : null}
+                                            </div>
+                                          </section>
+                                        </div>
+
+                                        <div className="market-columns">
+                                          <section>
+                                            <div>
+                                              <strong>Контекст сайта</strong>
+                                              <small>Смысловая рамка, от которой нельзя отрываться при расширении охвата.</small>
+                                            </div>
+                                            <div className="market-brief-list">
+                                              <div>
+                                                <span>{seoStrategy.evidence.context.status}</span>
+                                                <strong>{seoStrategy.evidence.context.summary}</strong>
+                                                <small>
+                                                  {seoStrategy.evidence.context.gaps.length > 0
+                                                    ? seoStrategy.evidence.context.gaps.slice(0, 4).join(" · ")
+                                                    : "Явных context gaps в strategy contract нет."}
+                                                </small>
+                                              </div>
+                                            </div>
+                                          </section>
+
+                                          <section>
+                                            <div>
+                                              <strong>Top demand signals</strong>
+                                              <small>Фразы с подтверждённой частотностью, которые реально влияют на стратегию.</small>
+                                            </div>
+                                            <div className="market-seed-list">
+                                              {seoStrategy.evidence.demand.topSignals.slice(0, 8).map((signal) => (
+                                                <div key={`${signal.phrase}:${signal.targetPath ?? "none"}`}>
+                                                  <span className="collected">{formatCount(signal.frequency ?? 0)}</span>
+                                                  <strong>{signal.phrase}</strong>
+                                                  <small>{signal.targetPath ?? "страница не выбрана"}</small>
+                                                </div>
+                                              ))}
+                                              {seoStrategy.evidence.demand.topSignals.length === 0 ? (
+                                                <div>
+                                                  <span>empty</span>
+                                                  <strong>Нет сильных demand signals</strong>
+                                                  <small>Нужно расширить сбор фраз и внешние источники.</small>
+                                                </div>
+                                              ) : null}
+                                            </div>
+                                          </section>
+                                        </div>
+
+                                        <div className="market-columns">
+                                          <section>
+                                            <div>
+                                              <strong>Варианты стратегии</strong>
+                                              <small>Пока это аналитические сценарии, не задачи на переписывание сайта.</small>
+                                            </div>
+                                            <div className="market-brief-list">
+                                              {seoStrategy.strategyOptions.map((option) => (
+                                                <div key={option.id}>
+                                                  <span>{option.expectedImpact} impact</span>
+                                                  <strong>{option.title}</strong>
+                                                  <small>
+                                                    effort {option.effort} · confidence {getSeoStrategyConfidenceLabel(option.confidence)}
+                                                  </small>
+                                                  <small>{option.rationale}</small>
+                                                </div>
+                                              ))}
+                                            </div>
+                                          </section>
+
+                                          <section>
+                                            <div>
+                                              <strong>Риски</strong>
+                                              <small>Почему стратегия может быть ошибочной без следующих проверок.</small>
+                                            </div>
+                                            <div className="market-brief-list">
+                                              {seoStrategy.risks.slice(0, 8).map((risk) => (
+                                                <div key={risk.id}>
+                                                  <span className={risk.level === "critical" ? "not_configured" : "ready_for_collection"}>
+                                                    {getSeoStrategyRiskLevelLabel(risk.level)}
+                                                  </span>
+                                                  <strong>{risk.title}</strong>
+                                                  <small>{risk.message}</small>
+                                                  <small>{risk.mitigation}</small>
+                                                </div>
+                                              ))}
+                                              {seoStrategy.risks.length === 0 ? (
+                                                <div>
+                                                  <span className="collected">OK</span>
+                                                  <strong>Критичных рисков нет</strong>
+                                                  <small>Остаётся закрыть недостающие evidence sources.</small>
+                                                </div>
+                                              ) : null}
+                                            </div>
+                                          </section>
+                                        </div>
+
+                                        <div className="market-next-actions">
+                                          <strong>Следующий production шаг</strong>
+                                          {seoStrategy.nextActions.map((action) => (
+                                            <p key={action}>{action}</p>
+                                          ))}
+                                        </div>
+                                      </>
+                                    ) : (
+                                      <div className="empty-state semantic-empty">
+                                        <GitBranch size={18} />
+                                        Сначала нужны context review, market enrichment и keyword map: стратегия не строится только на raw
+                                        scan.
+                                      </div>
+                                    )}
+                                  </section>
+                                ) : null}
+                                {activeStageIndex === -1 ? (
+                                  <section className="market-panel">
+                                    <div className="market-heading">
+                                      <div>
+                                        <strong>Подготовка к model review</strong>
+                                        <small>Что уже можно отдать на правку модели, а что сначала требует страницы или привязки.</small>
+                                      </div>
+                                      <FileText size={18} />
+                                    </div>
+
+                                    <div
+                                      className={`model-provider-panel ${
+                                        defaultModelProvider ? defaultModelProvider.status : "missing"
+                                      }`}
+                                    >
+                                      <div>
+                                        <span>Model provider</span>
+                                        <strong>
+                                          {defaultModelProvider
+                                            ? `${defaultModelProvider.title} · ${getModelProviderStatusLabel(defaultModelProvider.status)}`
+                                            : "Provider status не загружен"}
+                                        </strong>
+                                        <small>
+                                          {defaultModelProvider
+                                            ? defaultModelProvider.summary
+                                            : "Статус подтянется после обновления проекта."}
+                                        </small>
+                                      </div>
+                                      <div className="model-provider-run">
+                                        {latestModelTaskRun ? (
+                                          <>
+                                            <span>{getModelTaskRunStatusLabel(latestModelTaskRun.status)}</span>
+                                            <strong>
+                                              {latestModelTaskRun.task.taskType
+                                                ? getModelTaskTypeLabel(latestModelTaskRun.task.taskType)
+                                                : "model task"}{" "}
+                                              · {latestModelTaskRun.estimate.inputTokenEstimate} tokens
+                                            </strong>
+                                            <small>{formatDate(latestModelTaskRun.createdAt)}</small>
+                                          </>
+                                        ) : (
+                                          <>
+                                            <span>codex task</span>
+                                            <strong>Маршрут ещё не проверяли</strong>
+                                            <small>Task route фиксируется отдельно; результат анализа сохраняется manual evidence.</small>
+                                          </>
+                                        )}
+                                      </div>
+                                      <div className="model-provider-actions">
+                                        <button
+                                          className="tiny-action"
+                                          disabled={!semanticAnalysis || isRunningContextModelTask}
+                                          onClick={() => void handleSeoModelTaskRun(project, "seo.context_review")}
+                                          type="button"
+                                        >
+                                          {isRunningContextModelTask ? <Loader2 className="spin" size={14} /> : <Plug size={14} />}
+                                          Context Review
+                                        </button>
+                                        <button
+                                          className="tiny-action primary"
+                                          disabled={!semanticAnalysis || isRunningNormalizationModelTask}
+                                          onClick={() => void handleSeoModelTaskRun(project, "seo.normalization")}
+                                          type="button"
+                                        >
+                                          {isRunningNormalizationModelTask ? <Loader2 className="spin" size={14} /> : <Plug size={14} />}
+                                          Normalization
+                                        </button>
+                                        <button
+                                          className="tiny-action"
+                                          disabled={!keywordCleaning?.modelTask || isRunningKeywordCleaningModelTask}
+                                          onClick={() => void handleSeoModelTaskRun(project, "seo.keyword_cleaning")}
+                                          type="button"
+                                        >
+                                          {isRunningKeywordCleaningModelTask ? <Loader2 className="spin" size={14} /> : <Plug size={14} />}
+                                          Keyword Cleaning
+                                        </button>
+                                      </div>
+                                    </div>
+
+                                    {rewritePlan ? (
+                                      <>
+                                        <div
+                                          className={`market-state-card ${
+                                            rewritePlan.state === "ready_for_diff" || rewritePlan.state === "partial_ready"
+                                              ? "partial_ready"
+                                              : "not_ready"
+                                          }`}
+                                        >
+                                          <div>
+                                            <span>{getRewritePlanStateLabel(rewritePlan.state)}</span>
+                                            <strong>
+                                              Зафиксировано: {rewritePlan.readiness.approvedDecisionCount} · кандидатов на правки:{" "}
+                                              {rewritePlan.readiness.rewriteCandidateCount}
+                                            </strong>
+                                            <small>
+                                              Существующие страницы: {rewritePlan.readiness.existingPageTargetCount} · плановые:{" "}
+                                              {rewritePlan.readiness.plannedLandingTargetCount} · блокеры:{" "}
+                                              {rewritePlan.readiness.blockerCount}
+                                            </small>
+                                            <small>
+                                              Онтология:{" "}
+                                              {rewritePlan.projectOntologyVersionId
+                                                ? rewritePlan.projectOntologyVersionId.slice(0, 8)
+                                                : "нет"}{" "}
+                                              · анализ {rewritePlan.semanticRunId ? rewritePlan.semanticRunId.slice(0, 8) : "нет"}
+                                            </small>
+                                          </div>
+                                          <p>
+                                            {rewritePlan.state === "materialization_required"
+                                              ? "SEO-план есть, но часть посадочных ещё не существует в скане. Сначала нужно связать или отложить плановые страницы."
+                                              : rewritePlan.state === "ready_for_diff" || rewritePlan.state === "partial_ready"
+                                                ? "Есть привязки к существующим страницам; следующий слой может собрать правки для ручного review."
+                                                : "Model review ждёт зафиксированный SEO-план страниц."}
+                                          </p>
+                                        </div>
+
+                                        <div className={`seo-chart-grid ${materialization ? "seo-chart-grid-wide" : ""}`}>
+                                          <SeoFunnelChart
+                                            items={getRewriteReadinessFunnelData(rewritePlan, rewriteDiff)}
+                                            subtitle="от решений по фразам до готовых полей"
+                                            title="Готовность к review"
+                                          />
+                                          <SeoBarChart
+                                            items={getRewriteFieldBars(rewritePlan)}
+                                            subtitle="какие поля страницы участвуют в правках"
+                                            title="Поля страницы"
+                                          />
+                                          {materialization ? (
+                                            <SeoBarChart
+                                              items={getMaterializationBars(materialization)}
+                                              subtitle="плановые страницы перед правками"
+                                              title="Посадочные"
+                                            />
+                                          ) : null}
+                                        </div>
+
+                                        {rewritePlan.existingPageTargets.length > 0 ? (
+                                          <div className="market-columns">
+                                            <section>
+                                              <div>
+                                                <strong>Готово к правкам</strong>
+                                                <small>Существующие страницы, где уже понятны поле и секция.</small>
+                                              </div>
+                                              <div className="market-seed-list">
+                                                {rewritePlan.existingPageTargets.slice(0, 8).map((target) => (
+                                                  <div key={target.id}>
+                                                    <span>{target.keywordBindings.length} привязок</span>
+                                                    <strong>{target.urlPath ?? target.targetPath ?? target.pageTitle ?? "page"}</strong>
+                                                    <small>{target.sourcePath ?? target.pageId}</small>
+                                                  </div>
+                                                ))}
+                                              </div>
+                                            </section>
+
+                                            <section>
+                                              <div>
+                                                <strong>Инструкции для правок</strong>
+                                                <small>Рамки правок по конкретным полям страницы.</small>
+                                              </div>
+                                              <div className="market-brief-list">
+                                                {rewritePlan.existingPageTargets
+                                                  .flatMap((target) => target.keywordBindings)
+                                                  .slice(0, 8)
+                                                  .map((binding) => (
+                                                    <div key={`${binding.decisionId}-${binding.field}`}>
+                                                      <span>{getRewriteFieldLabel(binding.field)}</span>
+                                                      <strong>{binding.phrase}</strong>
+                                                      <small>{binding.instruction}</small>
+                                                    </div>
+                                                  ))}
+                                              </div>
+                                            </section>
+                                          </div>
+                                        ) : null}
+
+                                        {materialization ? (
+                                          <div
+                                            className={`market-state-card ${
+                                              materialization.state === "complete" || materialization.state === "partial"
+                                                ? "partial_ready"
+                                                : "not_ready"
+                                            }`}
+                                          >
+                                            <div>
+                                              <span>{getMaterializationStateLabel(materialization.state)}</span>
+                                              <strong>
+                                                Цели: {materialization.readiness.targetCount} · связано:{" "}
+                                                {materialization.readiness.linkedTargetCount}
+                                              </strong>
+                                              <small>
+                                                Ждёт решения: {materialization.readiness.pendingTargetCount} · плановых:{" "}
+                                                {materialization.readiness.placeholderTargetCount} · отложено/отклонено:{" "}
+                                                {materialization.readiness.rejectedOrDeferredCount}
+                                              </small>
+                                              <small>Source approved: {materialization.readiness.awaitingSourceCount}</small>
+                                              <small>План правок: {getRewritePlanStateLabel(materialization.rewritePlanState)}</small>
+                                            </div>
+                                            <p>
+                                              {materialization.state === "complete"
+                                                ? "Очередь посадочных закрыта для текущего плана review."
+                                                : "Здесь фиксируются решения по плановым посадочным; исходники сайта пока не меняются."}
+                                            </p>
+                                          </div>
+                                        ) : null}
+
+                                        {materialization && materialization.targets.length > 0 ? (
+                                          <div className="market-next-actions">
+                                            <strong>Почему model review пока рано</strong>
+                                            <div className="materialization-target-list">
+                                              {materialization.targets.slice(0, 8).map((target) => {
+                                                const targetPath = target.normalizedTargetPath ?? target.targetPath ?? "";
+
+                                                return (
+                                                  <div className="materialization-target" key={target.targetKey}>
+                                                    <div>
+                                                      <span>{getMaterializationStatusLabel(target.status)}</span>
+                                                      <strong>{targetPath || "без страницы"}</strong>
+                                                      <small>
+                                                        {target.keywordBindings.length} фраз ·{" "}
+                                                        {target.pageTitle ?? target.urlPath ?? target.sourcePath ?? "страница не связана"}
+                                                      </small>
+                                                      <small>
+                                                        Сейчас это аналитический blocker, а не задача на создание или правку файла сайта.
+                                                      </small>
+                                                    </div>
+                                                  </div>
+                                                );
+                                              })}
+                                            </div>
+                                          </div>
+                                        ) : null}
+
+                                        {rewriteDiff ? (
+                                          <div
+                                            className={`market-state-card ${
+                                              rewriteDiff.state === "ready_for_model_review" || rewriteDiff.state === "partial_ready"
+                                                ? "partial_ready"
+                                                : "not_ready"
+                                            }`}
+                                          >
+                                            <div>
+                                              <span>{getRewriteDiffStateLabel(rewriteDiff.state)}</span>
+                                              <strong>
+                                                Поля: {rewriteDiff.readiness.slotCount} · готовы:{" "}
+                                                {rewriteDiff.readiness.modelReadySlotCount}
+                                              </strong>
+                                              <small>
+                                                Ждут источника: {rewriteDiff.readiness.sourcePendingSlotCount} · посадочные:{" "}
+                                                {rewriteDiff.readiness.materializationTargetCount} · блокеры:{" "}
+                                                {rewriteDiff.readiness.blockerCount}
+                                              </small>
+                                            </div>
+                                            <p>
+                                              Контракт готовит текущие значения полей для review, но новый текст появится только после
+                                              выбора модели и правил промпта.
+                                            </p>
+                                          </div>
+                                        ) : null}
+
+                                        {rewriteDiff && rewriteDiff.targets.length > 0 ? (
+                                          <div className="market-columns">
+                                            <section>
+                                              <div>
+                                                <strong>Поля перед правкой</strong>
+                                                <small>В review идут только поля, где найден текущий текст.</small>
+                                              </div>
+                                              <div className="market-seed-list">
+                                                {rewriteDiff.targets
+                                                  .flatMap((target) =>
+                                                    target.slots.map((slot) => ({
+                                                      ...slot,
+                                                      pageLabel: target.urlPath ?? target.sourcePath ?? target.pageId
+                                                    }))
+                                                  )
+                                                  .slice(0, 8)
+                                                  .map((slot) => (
+                                                    <div key={slot.id}>
+                                                      <span>{getRewriteDiffSlotStatusLabel(slot.status)}</span>
+                                                      <strong>
+                                                        {getRewriteFieldLabel(slot.field)} · {slot.pageLabel}
+                                                      </strong>
+                                                      <small>
+                                                        {slot.source} · {slot.currentValue ? `${slot.currentValue.slice(0, 120)}...` : "нет значения"}
+                                                      </small>
+                                                    </div>
+                                                  ))}
+                                              </div>
+                                            </section>
+
+                                            <section>
+                                              <div>
+                                                <strong>Блокеры правок</strong>
+                                                <small>Что нужно закрыть до model review.</small>
+                                              </div>
+                                              <div className="market-brief-list">
+                                                {rewriteDiff.targets
+                                                  .flatMap((target) => target.slots)
+                                                  .filter((slot) => slot.blockers.length > 0)
+                                                  .slice(0, 8)
+                                                  .map((slot) => (
+                                                    <div key={`${slot.id}:blockers`}>
+                                                      <span>{getRewriteFieldLabel(slot.field)}</span>
+                                                      <strong>{slot.workspaceSectionId ?? "секция не найдена"}</strong>
+                                                      <small>{slot.blockers.join(" ")}</small>
+                                                    </div>
+                                                  ))}
+                                                {rewriteDiff.targets.flatMap((target) => target.slots).every((slot) => slot.blockers.length === 0) ? (
+                                                  <div>
+                                                    <span>готово</span>
+                                                    <strong>Блокеры не найдены</strong>
+                                                    <small>Следующий шаг — обсуждение model provider и review policy.</small>
+                                                  </div>
+                                                ) : null}
+                                              </div>
+                                            </section>
+                                          </div>
+                                        ) : null}
+
+                                        {rewritePlan.blockers.length > 0 || (rewriteDiff?.blockers.length ?? 0) > 0 ? (
+                                          <div className="market-next-actions">
+                                            <strong>Блокеры</strong>
+                                            {[...rewritePlan.blockers, ...(rewriteDiff?.blockers ?? [])].map((action) => (
+                                              <p key={action}>{action}</p>
+                                            ))}
+                                          </div>
+                                        ) : null}
+                                      </>
+                                    ) : (
+                                      <div className="empty-state semantic-empty">
+                                        <FileText size={18} />
+                                        Сначала нужен зафиксированный SEO-план: model review не создаёт правки без привязки страницы и секции.
+                                      </div>
+                                    )}
+                                  </section>
+                                ) : null}
+                                {activeStageIndex === 7 ? (
+                                  <section className="market-panel">
+                                    <div className="market-heading">
+                                      <div>
+                                        <strong>Проверка качества</strong>
+                                        <small>Quality gate стратегии: phase runway, evidence refs, hallucination guardrail и business drift. Сайт не меняем.</small>
+                                      </div>
+                                      <CheckCircle2 size={18} />
+                                    </div>
+
+                                    <div
+                                      className={`market-state-card ${
+                                        strategyQualityReview?.state === "ready"
+                                          ? getStrategyQualityVerdictClass(strategyQualityReview.verdict.status)
+                                          : "not_ready"
+                                      }`}
+                                    >
+                                      <div>
+                                        <span>
+                                          {strategyQualityReview?.state === "ready"
+                                            ? getStrategyQualityVerdictLabel(strategyQualityReview.verdict.status)
+                                            : "не собрано"}
+                                        </span>
+                                        <strong>
+                                          {strategyQualityReview?.state === "ready"
+                                            ? strategyQualityReview.verdict.title
+                                            : "Сначала нужна стратегия с phaseDecision и decision options"}
+                                        </strong>
+                                        <small>
+                                          {strategyQualityReview?.state === "ready"
+                                            ? `score ${strategyQualityReview.readiness.score} · checks ${strategyQualityReview.readiness.passedCount}/${strategyQualityReview.readiness.checkCount} · blockers ${strategyQualityReview.readiness.blockerCount}`
+                                            : "Этот gate проверяет аналитику, а не готовит source/apply route."}
+                                        </small>
+                                      </div>
+                                      <p>
+                                        {strategyQualityReview?.state === "ready"
+                                          ? strategyQualityReview.verdict.summary
+                                          : "Здесь фиксируем, можно ли доверять выбранной SEO-стратегии: нет ли преждевременных head terms, выдуманного спроса, расширения бизнеса без решения пользователя и мутных выводов."}
+                                      </p>
+                                    </div>
+
+                                    <div
+                                      className={`market-decision-board ${
+                                        strategyQualityReview?.state === "ready"
+                                          ? getChartToneClass(getStrategyTone(strategyQualityReview.readiness.score))
+                                          : "tone-warning"
+                                      }`}
+                                    >
+                                      <div className="market-decision-verdict">
+                                        <span>seo-strategy-quality-review.v1</span>
+                                        <strong>Read-only validation layer</strong>
+                                        <p>
+                                          Проверяем зрелость стратегии перед любыми будущими rewrite/apply действиями: фазовость, evidence,
+                                          hallucination guardrail, бизнесовую рамку и понятность следующего шага.
+                                        </p>
+                                        <div className="model-provider-actions">
+                                          <button
+                                            className="tiny-action"
+                                            disabled={!canPrepareStrategyQualityReview || isRunningStrategyQualityModelTask}
+                                            onClick={() => void handleSeoModelTaskRun(project, "seo.strategy_quality_review")}
+                                            type="button"
+                                          >
+                                            {isRunningStrategyQualityModelTask ? (
+                                              <Loader2 className="spin" size={14} />
+                                            ) : (
+                                              <Plug size={14} />
+                                            )}
+                                            Task route
+                                          </button>
+                                          <button
+                                            className="tiny-action primary"
+                                            disabled={!canPrepareStrategyQualityReview || isReviewingStrategyQuality}
+                                            onClick={() => void handleStrategyQualityReview(project)}
+                                            type="button"
+                                          >
+                                            {isReviewingStrategyQuality ? <Loader2 className="spin" size={14} /> : <CheckCircle2 size={14} />}
+                                            {isReviewingStrategyQuality ? "Проверяю..." : "Собрать review"}
+                                          </button>
+                                        </div>
+                                      </div>
+                                      <div className="market-decision-metrics">
+                                        {(strategyQualityReview?.state === "ready"
+                                          ? getStrategyQualityMetrics(strategyQualityReview)
+                                          : [
+                                              {
+                                                detail: "quality gate score",
+                                                label: "Score",
+                                                tone: "warning" as const,
+                                                value: 0
+                                              },
+                                              {
+                                                detail: "checks passed",
+                                                label: "Pass",
+                                                tone: "warning" as const,
+                                                value: 0
+                                              },
+                                              {
+                                                detail: "must fix",
+                                                label: "Blockers",
+                                                tone: "warning" as const,
+                                                value: 0
+                                              },
+                                              {
+                                                detail: "needs attention",
+                                                label: "Warnings",
+                                                tone: "warning" as const,
+                                                value: 0
+                                              }
+                                            ]).map((metric) => (
+                                          <article className={getChartToneClass(metric.tone)} key={`strategy-quality-metric:${metric.label}`}>
+                                            <span>{metric.label}</span>
+                                            <strong>{metric.value}</strong>
+                                            <small>{metric.detail}</small>
+                                          </article>
+                                        ))}
+                                      </div>
+                                    </div>
+
+                                    {strategyQualityReview?.state === "ready" ? (
+                                      <>
+                                        <div className="seo-chart-grid seo-chart-grid-wide">
+                                          <SeoShapeFunnelChart
+                                            items={getStrategyQualityMetrics(strategyQualityReview)}
+                                            subtitle="score, pass, blockers, warnings"
+                                            title="Quality gate"
+                                          />
+                                          <SeoRingChart
+                                            centerLabel="checks"
+                                            centerValue={strategyQualityReview.readiness.checkCount}
+                                            items={[
+                                              {
+                                                detail: "approved",
+                                                label: "Pass",
+                                                tone: "good",
+                                                value: strategyQualityReview.readiness.passedCount
+                                              },
+                                              {
+                                                detail: "warnings",
+                                                label: "Warn",
+                                                tone: "warning",
+                                                value: strategyQualityReview.readiness.warningCount
+                                              },
+                                              {
+                                                detail: "failed",
+                                                label: "Fail",
+                                                tone: "problem",
+                                                value: strategyQualityReview.readiness.blockerCount
+                                              }
+                                            ]}
+                                            subtitle="распределение проверок"
+                                            title="Checks"
+                                          />
+                                        </div>
+
+                                        <div className="market-columns">
+                                          <section>
+                                            <div>
+                                              <strong>Проверки</strong>
+                                              <small>Что именно удерживает или блокирует стратегию.</small>
+                                            </div>
+                                            <div className="market-brief-list">
+                                              {strategyQualityReview.checks.slice(0, 8).map((check) => (
+                                                <div key={check.id}>
+                                                  <span className={getStrategyQualityCheckClass(check.status)}>
+                                                    {getStrategyQualityCheckLabel(check.status)}
+                                                  </span>
+                                                  <strong>
+                                                    {getStrategyQualityCategoryLabel(check.category)} · {check.title}
+                                                  </strong>
+                                                  <small>{check.message}</small>
+                                                  <small>{check.action}</small>
+                                                  {check.evidenceRefs.length > 0 ? (
+                                                    <small>{check.evidenceRefs.slice(0, 3).join(" · ")}</small>
+                                                  ) : null}
+                                                </div>
+                                              ))}
+                                            </div>
+                                          </section>
+
+                                          <section>
+                                            <div>
+                                              <strong>Блокеры и warnings</strong>
+                                              <small>Короткий список того, что нельзя пропустить перед следующим аналитическим шагом.</small>
+                                            </div>
+                                            <div className="market-brief-list">
+                                              {strategyQualityReview.blockers.slice(0, 6).map((blocker) => (
+                                                <div key={`quality-blocker:${blocker}`}>
+                                                  <span className="not_configured">blocker</span>
+                                                  <strong>{blocker}</strong>
+                                                </div>
+                                              ))}
+                                              {strategyQualityReview.warnings.slice(0, 6).map((warning) => (
+                                                <div key={`quality-warning:${warning}`}>
+                                                  <span className="ready_for_collection">warning</span>
+                                                  <strong>{warning}</strong>
+                                                </div>
+                                              ))}
+                                              {strategyQualityReview.blockers.length === 0 && strategyQualityReview.warnings.length === 0 ? (
+                                                <div>
+                                                  <span className="collected">OK</span>
+                                                  <strong>Критичных замечаний нет</strong>
+                                                  <small>Можно переходить к следующему аналитическому слою, не к правке сайта.</small>
+                                                </div>
+                                              ) : null}
+                                            </div>
+                                          </section>
+                                        </div>
+
+                                        <div className="market-columns">
+                                          <section>
+                                            <div>
+                                              <strong>Approved signals</strong>
+                                              <small>Каким частям стратегии сейчас можно доверять.</small>
+                                            </div>
+                                            <div className="market-brief-list">
+                                              {strategyQualityReview.approvedSignals.slice(0, 8).map((signal) => (
+                                                <div key={`quality-signal:${signal}`}>
+                                                  <span className="collected">signal</span>
+                                                  <strong>{signal}</strong>
+                                                </div>
+                                              ))}
+                                            </div>
+                                          </section>
+
+                                          <section>
+                                            <div>
+                                              <strong>Следующий аналитический шаг</strong>
+                                              <small>Не action plan для сайта, а маршрут усиления доказательной базы.</small>
+                                            </div>
+                                            <div className="market-brief-list">
+                                              {strategyQualityReview.nextActions.map((action) => (
+                                                <div key={`quality-next:${action}`}>
+                                                  <span>next</span>
+                                                  <strong>{action}</strong>
+                                                </div>
+                                              ))}
+                                            </div>
+                                          </section>
+                                        </div>
+                                      </>
+                                    ) : (
+                                      <div className="empty-state semantic-empty">
+                                        <GitBranch size={18} />
+                                        Сначала собери `seo-strategy-synthesis.v1`: quality review проверяет принятую стратегию, phase runway и
+                                        evidence refs, а не raw keyword table.
                                       </div>
                                     )}
                                   </section>
@@ -4732,11 +10599,8 @@ export function App() {
                                         <div className="workspace-editor-stack workspace-cockpit">
                                           <div className="workspace-current-page">
                                             <div>
-                                              <span>
-                                                Активная страница {activeWorkspacePageIndex + 1}/{selectedWorkspaceScopeItems.length}
-                                              </span>
+                                              <small>{activeWorkspace.page.title ?? projectSiteTitle}</small>
                                               <strong>{activeWorkspaceScopeItem.title}</strong>
-                                              <small>{activeWorkspaceScopeItem.pathLabel}</small>
                                             </div>
                                           </div>
                                           <section className={`workspace-preview-panel workspace-cockpit-panel ${activeWorkspaceDrawers.length > 0 ? "drawer-open" : ""}`}>
@@ -5284,7 +11148,7 @@ export function App() {
           </div>
         </section>
 
-        {workspaceMode === "dev" && activeStageIndex > 3 ? (
+        {workspaceMode === "dev" && activeStageIndex > 6 ? (
           <section className="stage-placeholder">
             <div className="section-heading">
               <FolderCheck size={20} />
@@ -5300,6 +11164,8 @@ export function App() {
             </div>
           </section>
         ) : null}
+        </section>
+        ) : null}
 
         <footer className="footer-line">
           <GitBranch size={16} />
diff --git a/seo_mode/seo_mode/app/src/ProjectScopeFlow.tsx b/seo_mode/seo_mode/app/src/ProjectScopeFlow.tsx
index 5c3d9a5..e2b5145 100644
--- a/seo_mode/seo_mode/app/src/ProjectScopeFlow.tsx
+++ b/seo_mode/seo_mode/app/src/ProjectScopeFlow.tsx
@@ -14,7 +14,19 @@ import {
   useReactFlow
 } from "@xyflow/react";
 import "@xyflow/react/dist/style.css";
-import { FileText, Globe2, Layers3, LockKeyhole, Maximize2, Minus, PanelTop, Plus, RefreshCw, Save, Settings2 } from "lucide-react";
+import {
+  FileText,
+  Globe2,
+  Layers3,
+  LockKeyhole,
+  Maximize2,
+  Minus,
+  PanelTop,
+  Plus,
+  RefreshCw,
+  Save,
+  Settings2
+} from "lucide-react";
 import { memo, useCallback, useEffect, useMemo, useRef, useState } from "react";
 import {
   fetchProjectScopeLayout,
@@ -1079,8 +1091,6 @@ function shouldAutosaveNodeChanges(changes: NodeChange<ScopeFlowNode>[]) {
 
 export default function ProjectScopeFlow({
   isBusy,
-  onApplyRecommendedScope,
-  onClearSelection,
   onTogglePage,
   projectId,
   projectName,
@@ -1287,41 +1297,38 @@ export default function ProjectScopeFlow({
   }, [scheduleLayoutAutosave, selectionSignature]);
 
   const nodeTypes = useMemo(() => ({ scopeNode: ScopeNode }), []);
-  const groups = scopePriority
-    .map((scope) => ({
-      count: scope === "template_block" ? scan.siteSections.length : scan.pages.filter((page) => page.scope === scope).length,
-      selected:
-        scope === "template_block"
-          ? scan.siteSections.filter((section) => section.selected && section.enabled && section.pageId).length
-          : scan.pages.filter((page) => page.scope === scope && page.selected).length,
-      scope
-    }))
-    .filter((group) => group.count > 0);
+  const scopeDashboardItems = [
+    {
+      icon: <FileText size={13} />,
+      key: "indexable",
+      label: "Публичные страницы",
+      value: `${stats.selectedIndexable}/${stats.indexable}`
+    },
+    {
+      icon: <Layers3 size={13} />,
+      key: "sections",
+      label: "Секции главной",
+      value: `${stats.selectedSections}/${scan.siteSections.length}`
+    },
+    {
+      icon: <LockKeyhole size={13} />,
+      key: "admin",
+      label: "Админка",
+      value: `${stats.selectedAdmin}/${stats.admin}`
+    }
+  ];
 
   return (
     <section className="project-scope-flow-panel">
-      <div className="project-scope-flow-head">
-        <strong>Конфигурация проекта</strong>
-      </div>
-      <div className="project-scope-flow-controls">
-        <div className="project-scope-flow-legend">
-          {groups.map((group) => (
-            <span className={`scope-legend-item ${group.scope}`} key={group.scope}>
-              <FileText size={13} />
-              {scopeGroupNames[group.scope]} · {group.selected}/{group.count}
+      <div className="project-scope-flow-canvas">
+        <div className="project-scope-flow-stats nodrag nopan">
+          {scopeDashboardItems.map((item) => (
+            <span key={item.key}>
+              {item.icon}
+              {item.label} · {item.value}
             </span>
           ))}
         </div>
-        <div className="project-scope-flow-actions">
-          <button className="active" disabled={isBusy} onClick={onApplyRecommendedScope} type="button">
-            SEO scope
-          </button>
-          <button disabled={isBusy || stats.selectedWorkspaceItems === 0} onClick={onClearSelection} type="button">
-            Снять все
-          </button>
-        </div>
-      </div>
-      <div className="project-scope-flow-canvas">
         <ReactFlowProvider>
           <ReactFlow
             colorMode="light"
diff --git a/seo_mode/seo_mode/app/src/api.ts b/seo_mode/seo_mode/app/src/api.ts
index 01e20cd..0a792d0 100644
--- a/seo_mode/seo_mode/app/src/api.ts
+++ b/seo_mode/seo_mode/app/src/api.ts
@@ -199,6 +199,31 @@ export type SemanticAnalysisRun = {
     ctaPhrases: string[];
     toneSignals: string[];
   };
+  projectOntology?: {
+    id: string;
+    versionId: string | null;
+    version: number | null;
+    source: "seed_fixture" | "extracted" | "generic_fallback";
+    brandName: string;
+    domainPackage: {
+      id: "seo";
+      version: string;
+      coreOntologyVersion: string;
+      projectOntologySchema: "seo-project-ontology.v1";
+      packagePath: string;
+    };
+    instance: {
+      schemaVersion: "seo-project-ontology.v1";
+      siteId: string;
+      sourceType: string;
+      scanVersionId: string;
+      approvalStatus: "draft" | "approved" | "rejected" | "needs_review";
+      pageCount: number;
+      sectionCount: number;
+      intentClusterCount: number;
+      evidenceCount: number;
+    } | null;
+  };
   qualitySignals: Array<{
     id: string;
     level: "ok" | "warning" | "problem";
@@ -436,17 +461,275 @@ export type SemanticAnalysisRun = {
   nextActions: string[];
 };
 
+export type ProjectOntologyApprovalStatus = "approved" | "draft" | "needs_review" | "rejected";
+
+export type ProjectOntologyConfirmationState = {
+  confirmed: boolean;
+  confirmedAt: string | null;
+  confirmedBy: string | null;
+};
+
+export type ProjectOntologyVersion = {
+  id: string;
+  projectId: string;
+  scanVersionId: string | null;
+  semanticRunId: string | null;
+  version: number;
+  schemaVersion: "seo-project-ontology.v1";
+  source: "seed_fixture" | "extracted" | "generic_fallback";
+  brandName: string;
+  approvalStatus: ProjectOntologyApprovalStatus;
+  domainPackage: {
+    id: "seo";
+    version: string;
+    coreOntologyVersion: string;
+    projectOntologySchema: "seo-project-ontology.v1";
+    packagePath: string;
+  };
+  evidenceSummary: {
+    pageCount: number;
+    sectionCount: number;
+    intentClusterCount: number;
+    evidenceCount: number;
+    confirmations?: {
+      brand: ProjectOntologyConfirmationState;
+      aliases: ProjectOntologyConfirmationState;
+    };
+    reviewItems?: Array<{
+      id: string;
+      level: "ok" | "problem" | "warning";
+      title: string;
+      message: string;
+    }>;
+    pages: Array<{
+      id: string;
+      url: string;
+      title: string;
+    }>;
+    intentClusters: Array<{
+      id: string;
+      title: string;
+      priority: "high" | "medium" | "low";
+    }>;
+    evidence: Array<{
+      id: string;
+      sourceType: string;
+      ref: string;
+      summary: string;
+    }>;
+  };
+  createdAt: string;
+  updatedAt: string;
+  approvedAt: string | null;
+  approvedBy: string | null;
+};
+
 export type SemanticExportFormat = "csv" | "json" | "markdown";
 
+export type SeoContextReviewRun = {
+  schemaVersion: "seo-context-review.v1";
+  projectId: string;
+  semanticRunId: string;
+  scanVersionId: string;
+  projectOntologyVersionId: string | null;
+  generatedAt: string;
+  runId: string;
+  status: string;
+  provider: {
+    mode: "codex_manual" | "deterministic_fallback";
+    modelRequired: true;
+    message: string;
+  };
+  analystReview: {
+    status: "approved" | "needs_changes" | "not_reviewed" | "rejected";
+    reviewer: "codex" | "human" | "system";
+    reviewedAt: string | null;
+    notes: string[];
+  };
+  readiness: {
+    evidenceRefCount: number;
+    pageRoleCount: number;
+    semanticGapCount: number;
+    forbiddenClaimCount: number;
+    normalizationHintCount: number;
+    needsHumanReview: boolean;
+  };
+  siteIdentity: {
+    brandName: string;
+    description: string;
+    confidence: "high" | "low" | "medium";
+    evidenceRefs: string[];
+  };
+  forbiddenClaims: Array<{
+    id: string;
+    claim: string;
+    reason: string;
+    source: "guardrail" | "semantic_gap" | "weak_evidence";
+  }>;
+  normalizationHints: Array<{
+    id: string;
+    clusterId: string;
+    title: string;
+    targetIntent: string;
+    sourcePhrases: string[];
+    marketAngles: string[];
+    stopPhrases: string[];
+    reviewRequired: boolean;
+    reason: string;
+  }>;
+  risks: Array<{
+    id: string;
+    level: "ok" | "problem" | "warning";
+    title: string;
+    message: string;
+  }>;
+  needsHumanReview: boolean;
+  summary: string;
+  nextActions: string[];
+};
+
+export type SeoNormalizationContract = {
+  schemaVersion: "seo-normalization.v1";
+  projectId: string;
+  semanticRunId: string | null;
+  projectOntologyVersionId: string | null;
+  generatedAt: string;
+  state: "not_ready" | "ready";
+  provider: {
+    mode: "codex_manual" | "deterministic_fallback";
+    modelRequired: boolean;
+    message: string;
+  };
+  sourceTaskId: string | null;
+  analystReview: {
+    status: "approved" | "needs_changes" | "not_reviewed" | "rejected";
+    reviewer: "codex" | "human" | "system";
+    reviewedAt: string | null;
+    notes: string[];
+  };
+  modelTask: {
+    taskType: "seo.normalization";
+    schemaVersion: "seo-normalization-task.v1";
+    taskId: string;
+    projectId: string;
+    semanticRunId: string;
+    projectOntologyVersionId: string | null;
+    providerMode: "model_provider_contract";
+    allowedActions: Array<
+      | "group_intents"
+      | "normalize_market_queries"
+      | "reject_noise"
+      | "mark_human_review"
+      | "route_wordstat"
+      | "route_serp"
+    >;
+    outputSchema: {
+      schemaVersion: "seo-normalization.v1";
+      requiredTopLevelKeys: string[];
+      seedRequiredKeys: string[];
+      intentRequiredKeys: string[];
+    };
+    confidencePolicy: {
+      autoApproveMinConfidence: number;
+      humanReviewBelowConfidence: number;
+      rejectWhenOffBusiness: boolean;
+    };
+    stopConditions: string[];
+  } | null;
+  readiness: {
+    sourceSeedCount: number;
+    normalizedSeedCount: number;
+    intentGroupCount: number;
+    wordstatQueryCount: number;
+    wordstatApprovedCount: number;
+    serpApprovedCount: number;
+    rejectedSeedCount: number;
+    needsHumanReviewCount: number;
+    autoApprovedCount: number;
+  };
+  summary: string;
+  intentGroups: Array<{
+    id: string;
+    title: string;
+    intentType:
+      | "commercial"
+      | "deployment_security"
+      | "enterprise"
+      | "informational"
+      | "integration"
+      | "problem"
+      | "product"
+      | "support";
+    priority: "high" | "medium" | "low";
+    marketHypothesis: string;
+    sourceClusterIds: string[];
+    sourceRefs: Array<{
+      title: string;
+      sourcePath: string;
+      urlPath: string | null;
+      scope: string;
+    }>;
+    corePhrases: string[];
+    wordstatQueries: string[];
+    excludedPhrases: Array<{
+      phrase: string;
+      reason: string;
+    }>;
+    risks: string[];
+    confidence: number;
+  }>;
+  seedStrategy: Array<{
+    id: string;
+    phrase: string;
+    normalizedFrom: string[];
+    clusterId: string;
+    clusterTitle: string;
+    intentGroupId: string;
+    intentType: SeoNormalizationContract["intentGroups"][number]["intentType"];
+    marketRole: "commercial" | "core" | "exclude" | "integration" | "problem" | "support";
+    priority: "high" | "medium" | "low";
+    source: "detected" | "ontology";
+    reason: string;
+    confidence: number;
+    needsHumanReview: boolean;
+    review: {
+      status: "auto_approved" | "needs_human" | "rejected";
+      sendToWordstat: boolean;
+      sendToSerp: boolean;
+      reason: string;
+      blockers: string[];
+    };
+  }>;
+  rejectedSeeds: Array<{
+    phrase: string;
+    clusterId: string;
+    clusterTitle: string;
+    reason: string;
+    suggestedReplacement: string | null;
+  }>;
+  nextActions: string[];
+};
+
 export type MarketEnrichmentContract = {
   schemaVersion: "market-enrichment.v1";
   projectId: string;
   semanticRunId: string | null;
+  projectOntologyVersion: {
+    id: string;
+    version: number;
+    approvalStatus: ProjectOntologyApprovalStatus;
+    brandName: string;
+    schemaVersion: "seo-project-ontology.v1";
+    domainPackage: ProjectOntologyVersion["domainPackage"];
+    reviewProblemCount: number;
+  } | null;
   generatedAt: string;
   state: "not_ready" | "not_collected" | "not_configured" | "partial_ready";
+  normalization: SeoNormalizationContract;
   readiness: {
     canCollectWordstat: boolean;
     canCollectSerp: boolean;
+    ontologyReadyForMarket: boolean;
     seedCount: number;
     briefCount: number;
     configuredProviderCount: number;
@@ -468,6 +751,17 @@ export type MarketEnrichmentContract = {
     clusterTitle: string;
     priority: "high" | "medium" | "low";
     source: "detected" | "ontology";
+    normalization: {
+      intentGroupId: string;
+      intentType: SeoNormalizationContract["intentGroups"][number]["intentType"];
+      marketRole: SeoNormalizationContract["seedStrategy"][number]["marketRole"];
+      normalizedFrom: string[];
+      confidence: number;
+      needsHumanReview: boolean;
+      reviewStatus: SeoNormalizationContract["seedStrategy"][number]["review"]["status"];
+      reviewReason: string;
+      sendToSerp: boolean;
+    } | null;
     evidenceStatus:
       | "collection_failed"
       | "collected"
@@ -483,9 +777,12 @@ export type MarketEnrichmentContract = {
     frequencyGroup: string | null;
     relatedCount: number;
     lastCollectedAt: string | null;
+    projectOntologyVersionId: string | null;
+    wordstatResultId: string | null;
   }>;
   briefEvidence: Array<{
     path: string;
+    clusterIds: string[];
     priority: "high" | "medium" | "low";
     action: "create" | "strengthen" | "validate";
     qualityScore: number | null;
@@ -494,6 +791,7 @@ export type MarketEnrichmentContract = {
     evidenceStatus: "deterministic_only" | "not_collected" | "not_configured" | "ready_for_collection";
     requiredProviders: Array<"model" | "serp" | "text_quality" | "wordstat">;
     missingEvidence: string[];
+    projectOntologyVersionId: string | null;
   }>;
   wordstat: {
     latestJob: {
@@ -512,6 +810,7 @@ export type MarketEnrichmentContract = {
       updatedAt: string;
     } | null;
     seedResults: Array<{
+      id: string;
       seedId: string | null;
       phrase: string;
       sourcePhrase: string | null;
@@ -522,6 +821,7 @@ export type MarketEnrichmentContract = {
       collectedAt: string;
     }>;
     topResults: Array<{
+      id: string;
       phrase: string;
       sourcePhrase: string | null;
       frequency: number | null;
@@ -543,6 +843,942 @@ export type MarketEnrichmentContract = {
   nextActions: string[];
 };
 
+export type KeywordCleaningItem = {
+  id: string;
+  phrase: string;
+  normalizedPhrase: string;
+  source: "manual" | "normalization_seed" | "serp" | "wordstat_related" | "wordstat_seed";
+  sourcePhrase: string | null;
+  clusterId: string;
+  clusterTitle: string;
+  targetPath: string | null;
+  priority: "high" | "medium" | "low";
+  seedSource: "detected" | "ontology";
+  intentType: SeoNormalizationContract["intentGroups"][number]["intentType"] | null;
+  marketRole: SeoNormalizationContract["seedStrategy"][number]["marketRole"] | null;
+  evidenceStatus: MarketEnrichmentContract["seedQueue"][number]["evidenceStatus"];
+  frequency: number | null;
+  frequencyGroup: string | null;
+  relatedCount: number;
+  projectOntologyVersionId: string | null;
+  wordstatResultId: string | null;
+  decision: "article" | "risky" | "support" | "trash" | "use";
+  confidence: number;
+  reason: string;
+  blockers: string[];
+  evidenceRefs: string[];
+};
+
+export type KeywordCleaningContract = {
+  schemaVersion: "keyword-cleaning.v1";
+  projectId: string;
+  semanticRunId: string | null;
+  projectOntologyVersion: MarketEnrichmentContract["projectOntologyVersion"];
+  generatedAt: string;
+  state: "not_ready" | "ready";
+  provider: {
+    mode: "codex_manual" | "deterministic_fallback";
+    modelRequired: boolean;
+    message: string;
+  };
+  sourceTaskId: string | null;
+  analystReview: {
+    status: "approved" | "needs_changes" | "not_reviewed" | "rejected";
+    reviewer: "codex" | "human" | "system";
+    reviewedAt: string | null;
+    notes: string[];
+  };
+  source: {
+    marketState: MarketEnrichmentContract["state"];
+    marketGeneratedAt: string;
+    marketSeedCount: number;
+    wordstatJobId: string | null;
+    wordstatJobStatus: string | null;
+    wordstatResultCount: number;
+  };
+  modelTask: {
+    taskType: "seo.keyword_cleaning";
+    schemaVersion: "seo-keyword-cleaning-task.v1";
+    taskId: string;
+    projectId: string;
+    semanticRunId: string;
+    projectOntologyVersionId: string | null;
+    providerMode: "model_provider_contract";
+    allowedActions: string[];
+    inputStats: {
+      marketSeedCount: number;
+      wordstatResultCount: number;
+      wordstatJobStatus: string | null;
+    };
+    outputSchema: {
+      schemaVersion: "keyword-cleaning.v1";
+      requiredTopLevelKeys: string[];
+      itemRequiredKeys: string[];
+    };
+    decisionPolicy: {
+      useRequiresExactEvidence: boolean;
+      riskyWhenNoPageBinding: boolean;
+      trashWhenOffContext: boolean;
+      articleDoesNotEnterRewrite: boolean;
+    };
+    stopConditions: string[];
+  } | null;
+  readiness: {
+    sourcePhraseCount: number;
+    useCount: number;
+    supportCount: number;
+    articleCount: number;
+    riskyCount: number;
+    trashCount: number;
+    keywordMapCandidateCount: number;
+    exactEvidenceCount: number;
+    missingPageBindingCount: number;
+  };
+  lanes: Record<"article" | "risky" | "support" | "trash" | "use", KeywordCleaningItem[]>;
+  items: KeywordCleaningItem[];
+  summary: string;
+  nextActions: string[];
+};
+
+export type SeoModelTaskType =
+  | "seo.context_review"
+  | "seo.keyword_cleaning"
+  | "seo.normalization"
+  | "seo.serp_interpretation"
+  | "seo.strategy_quality_review"
+  | "seo.strategy_synthesis";
+export type SeoModelProviderId =
+  | "codex_manual"
+  | "codex_workspace"
+  | "contract_dry_run"
+  | "external_agent"
+  | "local_model"
+  | "openai_api";
+
+export type SeoModelProviderDescriptor = {
+  id: SeoModelProviderId;
+  status: "active" | "not_configured" | "planned";
+  title: string;
+  mode: "api_model" | "dry_run" | "local_runtime" | "manual_dev_loop" | "mcp_agent" | "workspace_agent";
+  summary: string;
+  allowedTaskTypes: SeoModelTaskType[];
+  requiresSecrets: boolean;
+  secretNames: string[];
+  capabilities: {
+    structuredJson: boolean;
+    toolUse: boolean;
+    streaming: boolean;
+    contextWindowTokens: number | null;
+    rateLimitPolicy: string;
+    costPolicy: string;
+    supportsCancel: boolean;
+  };
+  guardrails: string[];
+  nextSetupStep: string;
+};
+
+export type SeoModelProviderCatalog = {
+  schemaVersion: "seo-model-provider-catalog.v1";
+  generatedAt: string;
+  defaultProviderId: SeoModelProviderId;
+  providers: SeoModelProviderDescriptor[];
+};
+
+export type SeoModelTaskRun = {
+  schemaVersion: "seo-model-task-run.v1";
+  runId: string;
+  runStatus: "cancelled" | "done" | "failed" | "queued" | "running";
+  input: Record<string, unknown>;
+  startedAt: string | null;
+  completedAt: string | null;
+  errorMessage: string | null;
+  createdAt: string;
+  projectId: string;
+  generatedAt: string;
+  provider: Pick<SeoModelProviderDescriptor, "id" | "mode" | "status" | "title">;
+  task: {
+    taskId: string | null;
+    taskType: SeoModelTaskType | null;
+    schemaVersion: string | null;
+    semanticRunId: string | null;
+    activeSkillId: string | null;
+    providerMode: string | null;
+    outputSchemaVersion: string | null;
+    requiredTopLevelKeys: string[];
+    allowedActionCount: number;
+    stopConditionCount: number;
+    sourceContextVersion: "seo-model-context.v1";
+  };
+  status: "contract_ready" | "provider_not_configured" | "task_not_found" | "validation_failed";
+  validation: {
+    ok: boolean;
+    errors: string[];
+    warnings: string[];
+    notes: string[];
+  };
+  estimate: {
+    inputChars: number;
+    inputTokenEstimate: number;
+    outputTokenBudget: number;
+  };
+  modelOutput: null;
+  persistedResult: null;
+  nextActions: string[];
+};
+
+export type SeoModelProviderStatusContract = {
+  schemaVersion: "seo-model-provider-status.v1";
+  projectId: string;
+  generatedAt: string;
+  catalog: SeoModelProviderCatalog;
+  latestRuns: SeoModelTaskRun[];
+};
+
+export type YandexEvidenceContract = {
+  schemaVersion: "yandex-evidence.v1";
+  projectId: string;
+  semanticRunId: string | null;
+  runId: string | null;
+  generatedAt: string;
+  state: "failed" | "not_collected" | "not_configured" | "ready";
+  provider: {
+    configured: boolean;
+    authType: "api_key" | "iam_token" | null;
+    folderId: string | null;
+    mode: string;
+  };
+  input: {
+    phraseLimit: number;
+    phrases: Array<{
+      phrase: string;
+      targetPath: string | null;
+      priority: "high" | "low" | "medium";
+      source: "keyword_map" | "market_seed" | "top_demand";
+      reason: string;
+    }>;
+  };
+  summary: {
+    checkedPhraseCount: number;
+    okPhraseCount: number;
+    totalDemand: number;
+    risingPhraseCount: number;
+    serpDocCount: number;
+    competitorDomainCount: number;
+    topDomains: Array<{
+      domain: string;
+      count: number;
+    }>;
+  };
+  capabilities: Array<{
+    id: "serp" | "wordstat_dynamics" | "wordstat_regions" | "wordstat_top";
+    ok: boolean;
+    summary: string;
+  }>;
+  phrases: Array<{
+    phrase: string;
+    targetPath: string | null;
+    priority: "high" | "low" | "medium";
+    source: "keyword_map" | "market_seed" | "top_demand";
+    status: "failed" | "ok" | "partial";
+    errors: string[];
+    wordstat: {
+      totalCount: number | null;
+      topRequests: Array<{ phrase: string; count: number | null }>;
+      associations: Array<{ phrase: string; count: number | null }>;
+      regions: Array<{ affinityIndex: number | null; count: number | null; region: string; share: number | null }>;
+      dynamics: Array<{ count: number | null; date: string; share: number | null }>;
+    };
+    serp: {
+      found: Record<string, number>;
+      docs: Array<{
+        domain: string;
+        url: string;
+        title: string;
+        snippet: string;
+        mime: string;
+        lang: string;
+        pageType: "article" | "docs" | "home" | "landing" | "marketplace" | "product" | "unknown";
+      }>;
+      topDomains: string[];
+    };
+    interpretation: {
+      demandTier: "high" | "low" | "mid" | "no_signal";
+      difficultyScore: number;
+      nextDataNeeded: string[];
+      opportunity: string;
+      risk: string | null;
+      seasonality: "falling" | "insufficient" | "rising" | "stable" | "volatile";
+      serpIntent: "commercial" | "informational" | "mixed" | "unknown";
+    };
+  }>;
+  competitorDomains: Array<{
+    domain: string;
+    count: number;
+    sampleTitle: string;
+    sampleUrl: string;
+  }>;
+  nextActions: string[];
+};
+
+export type SerpInterpretationContract = {
+  schemaVersion: "seo-serp-interpretation.v1";
+  projectId: string;
+  semanticRunId: string | null;
+  runId: string | null;
+  yandexEvidenceRunId: string | null;
+  generatedAt: string;
+  state: "not_ready" | "ready";
+  provider: {
+    mode: "codex_manual" | "deterministic_fallback";
+    modelRequired: true;
+    message: string;
+  };
+  sourceTaskId: string | null;
+  analystReview: {
+    status: "approved" | "needs_changes" | "not_reviewed" | "rejected";
+    reviewer: "codex" | "human" | "system";
+    reviewedAt: string | null;
+    notes: string[];
+  };
+  readiness: {
+    competitorGapCount: number;
+    interpretedPhraseCount: number;
+    mismatchCount: number;
+    nextEvidenceCount: number;
+    phraseCount: number;
+    riskCount: number;
+  };
+  yandexEvidence: {
+    checkedPhraseCount: number;
+    competitorDomainCount: number;
+    runId: string | null;
+    serpDocCount: number;
+    totalDemand: number;
+  };
+  phraseInterpretations: Array<{
+    phrase: string;
+    targetPath: string | null;
+    intent: YandexEvidenceContract["phrases"][number]["interpretation"]["serpIntent"];
+    targetFit: "mismatch" | "partial_fit" | "strong_fit" | "unknown";
+    recommendedRole: "article_backlog" | "core_landing" | "human_review" | "support_section";
+    totalDemand: number | null;
+    demandTier: YandexEvidenceContract["phrases"][number]["interpretation"]["demandTier"];
+    seasonality: YandexEvidenceContract["phrases"][number]["interpretation"]["seasonality"];
+    difficultyScore: number;
+    confidence: "high" | "low" | "medium";
+    opportunity: string;
+    risk: string | null;
+    evidenceRefs: string[];
+    nextEvidenceNeeded: string[];
+    topDomains: string[];
+  }>;
+  competitorGaps: Array<{
+    count: number;
+    domain: string;
+    observedAngle: string;
+    sampleTitle: string;
+    sampleUrl: string;
+    strategyImplication: string;
+    evidenceRefs: string[];
+  }>;
+  strategySignals: Array<{
+    id: string;
+    title: string;
+    priority: "high" | "low" | "medium";
+    confidence: "high" | "low" | "medium";
+    message: string;
+    evidenceRefs: string[];
+  }>;
+  risks: Array<{
+    id: string;
+    level: "critical" | "high" | "medium";
+    title: string;
+    message: string;
+    mitigation: string;
+    evidenceRefs: string[];
+  }>;
+  summary: string;
+  nextActions: string[];
+};
+
+export type KeywordMapContract = {
+  schemaVersion: "keyword-map.v1";
+  projectId: string;
+  semanticRunId: string | null;
+  projectOntologyVersion: MarketEnrichmentContract["projectOntologyVersion"];
+  generatedAt: string;
+  state: "blocked" | "draft";
+  readiness: {
+    reviewedOntology: boolean;
+    seedCount: number;
+    mappedItemCount: number;
+    marketEvidenceCount: number;
+    persistableItemCount: number;
+    blockerCount: number;
+  };
+  cleaning: {
+    schemaVersion: "keyword-cleaning.v1";
+    providerMode: KeywordCleaningContract["provider"]["mode"];
+    analystStatus: KeywordCleaningContract["analystReview"]["status"];
+    sourcePhraseCount: number;
+    useCount: number;
+    supportCount: number;
+    articleCount: number;
+    riskyCount: number;
+    trashCount: number;
+    keywordMapCandidateCount: number;
+  };
+  blockers: string[];
+  persisted: {
+    approvedDecisionCount: number;
+    mapItemCount: number;
+    latestApprovedAt: string | null;
+    items: Array<{
+      decisionId: string;
+      mapItemId: string | null;
+      sourceItemId: string | null;
+      phrase: string;
+      role: "primary" | "secondary" | "support" | "validate" | string;
+      targetPath: string | null;
+      workspaceSectionId: string | null;
+      pageId: string | null;
+      approvedAt: string;
+    }>;
+  };
+  items: Array<{
+    id: string;
+    phrase: string;
+    role: "primary" | "secondary" | "support" | "validate";
+    clusterId: string;
+    clusterTitle: string;
+    targetPath: string | null;
+    priority: "high" | "medium" | "low";
+    source: "detected" | "ontology";
+    evidenceStatus: MarketEnrichmentContract["seedQueue"][number]["evidenceStatus"];
+    frequency: number | null;
+    frequencyGroup: string | null;
+    projectOntologyVersionId: string | null;
+    wordstatResultId: string | null;
+    reason: string;
+  }>;
+  nextActions: string[];
+};
+
+export type SeoStrategyContract = {
+  schemaVersion: "seo-strategy.v1";
+  projectId: string;
+  semanticRunId: string | null;
+  projectOntologyVersion: MarketEnrichmentContract["projectOntologyVersion"];
+  generatedAt: string;
+  state: "blocked" | "evidence_gap" | "ready_for_review" | "strategy_draft";
+  verdict: {
+    title: string;
+    summary: string;
+    confidence: "high" | "low" | "medium";
+    primaryConstraint: string;
+  };
+	  readiness: {
+    approvedKeywordCount: number;
+    contextReady: boolean;
+    evidenceGapCount: number;
+    externalProviderConnectedCount: number;
+    marketEvidenceCount: number;
+    opportunityCount: number;
+    riskCount: number;
+    strategyConfidenceScore: number;
+	    trashFilteredCount: number;
+	  };
+	  siteMaturity: {
+	    schemaVersion: "site-maturity.v1";
+	    phase: "authority_head_terms" | "bootstrap_indexing" | "growth" | "traction";
+	    confidence: "high" | "low" | "medium";
+	    reason: string;
+	    signals: {
+	      approvedKeywordCount: number;
+	      hasAuthorityEvidence: boolean;
+	      hasIndexEvidence: boolean;
+	      hasPerformanceEvidence: boolean;
+	      hasSerpInterpretation: boolean;
+	      hasTractionEvidence: boolean;
+	      marketEvidenceCount: number;
+	      totalDemand: number;
+	    };
+	    allowedNow: string[];
+	    holdUntil: string[];
+	    promotionSignals: string[];
+	    guardrails: string[];
+	  };
+	  phasePlan: Array<{
+	    phase: SeoStrategyContract["siteMaturity"]["phase"];
+	    title: string;
+	    status: "current" | "future" | "locked" | "ready";
+	    goal: string;
+	    allowedTargets: string[];
+	    deferredTargets: string[];
+	    promotionSignals: string[];
+	    risk: string;
+	  }>;
+	  evidence: {
+    context: {
+      status: "missing" | "needs_review" | "ready";
+      summary: string;
+      gaps: string[];
+    };
+    demand: {
+      exactSeedCount: number;
+      usefulCandidateCount: number;
+      rejectedNoiseCount: number;
+      riskyCandidateCount: number;
+      topSignals: Array<{
+        phrase: string;
+        frequency: number | null;
+        targetPath: string | null;
+      }>;
+      totalFrequency: number;
+    };
+    providers: Array<{
+      id: MarketEnrichmentContract["providers"][number]["id"];
+      label: string;
+      status: MarketEnrichmentContract["providers"][number]["status"];
+      impact: string;
+      nextStep: string;
+    }>;
+    yandex: {
+      state: YandexEvidenceContract["state"];
+      runId: string | null;
+      checkedPhraseCount: number;
+      totalDemand: number;
+      serpDocCount: number;
+      competitorDomainCount: number;
+      topDomains: Array<{
+        domain: string;
+        count: number;
+      }>;
+      nextStep: string;
+    };
+    serpInterpretation: {
+      state: SerpInterpretationContract["state"];
+      runId: string | null;
+      yandexEvidenceRunId: string | null;
+      interpretedPhraseCount: number;
+      mismatchCount: number;
+      competitorGapCount: number;
+      riskCount: number;
+      nextStep: string;
+    };
+  };
+  opportunities: Array<{
+    id: string;
+    title: string;
+    category: "content_gap" | "core_demand" | "market_expansion" | "proof_gap" | "technical_blocker";
+    confidence: "high" | "low" | "medium";
+    demand: {
+      phraseCount: number;
+      totalFrequency: number;
+      topPhrase: string | null;
+    };
+	    evidenceRefs: string[];
+	    nextDataNeeded: string[];
+	    priority: "high" | "low" | "medium";
+	    competitionTier: "head" | "long_tail" | "mid" | "unknown";
+	    recommendation: string;
+	    targetPath: string | null;
+	    timing: {
+	      action: "defer" | "do_now" | "prepare";
+	      currentPhase: SeoStrategyContract["siteMaturity"]["phase"];
+	      earliestPhase: SeoStrategyContract["siteMaturity"]["phase"];
+	      reason: string;
+	      promotionSignal: string;
+	    };
+	    whyItMatters: string;
+	  }>;
+  risks: Array<{
+    id: string;
+    title: string;
+    level: "critical" | "high" | "medium";
+    message: string;
+    mitigation: string;
+  }>;
+  strategyOptions: Array<{
+    id: string;
+    title: string;
+    confidence: "high" | "low" | "medium";
+    effort: "high" | "low" | "medium";
+    expectedImpact: "high" | "low" | "medium";
+    rationale: string;
+    requiredEvidence: string[];
+  }>;
+  missingEvidence: Array<{
+    id: string;
+    title: string;
+    impact: string;
+    owner: "ai_layer" | "external_service" | "product_review";
+    priority: "high" | "low" | "medium";
+  }>;
+  nextActions: string[];
+};
+
+export type StrategySynthesisContract = {
+  schemaVersion: "seo-strategy-synthesis.v1";
+  projectId: string;
+  semanticRunId: string | null;
+  runId: string | null;
+  generatedAt: string;
+  state: "not_ready" | "ready";
+  provider: {
+    mode: "codex_manual" | "deterministic_fallback";
+    modelRequired: true;
+    message: string;
+  };
+  sourceTaskId: string | null;
+  sourceStrategyGeneratedAt: string | null;
+  sourceSerpInterpretationRunId: string | null;
+  analystReview: {
+    status: "approved" | "needs_changes" | "not_reviewed" | "rejected";
+    reviewer: "codex" | "human" | "system";
+    reviewedAt: string | null;
+    notes: string[];
+  };
+  readiness: {
+    confidenceScore: number;
+    dataGapCount: number;
+    decisionOptionCount: number;
+    evidenceNarrativeCount: number;
+    nextActionCount: number;
+    riskCount: number;
+  };
+	  executiveSummary: {
+    title: string;
+    verdict: string;
+    confidence: "high" | "low" | "medium";
+    whyNow: string;
+	    primaryConstraint: string;
+	  };
+	  phaseDecision: {
+	    schemaVersion: "seo-phase-decision.v1";
+	    currentPhase: SeoStrategyContract["siteMaturity"]["phase"];
+	    title: string;
+	    summary: string;
+	    allowedNow: string[];
+	    prepareNext: string[];
+	    hold: string[];
+	    promotionSignals: string[];
+	    phaseRoadmap: SeoStrategyContract["phasePlan"];
+	  };
+	  recommendedPath: {
+    id: string;
+    title: string;
+    priority: "high" | "low" | "medium";
+    expectedImpact: "high" | "low" | "medium";
+    confidence: "high" | "low" | "medium";
+    rationale: string;
+    doNow: string[];
+    hold: string[];
+    needsEvidence: string[];
+  };
+  decisionOptions: Array<{
+	    id: string;
+	    title: string;
+	    scenario: "analytics_first" | "bootstrap_runway" | "core_growth" | "risk_reduction" | "serp_expansion";
+    priority: "high" | "low" | "medium";
+    expectedImpact: "high" | "low" | "medium";
+    effort: "high" | "low" | "medium";
+    confidence: "high" | "low" | "medium";
+    rationale: string;
+    nextStep: string;
+    evidenceRefs: string[];
+    risks: string[];
+  }>;
+  evidenceNarrative: Array<{
+    id: string;
+    title: string;
+    whatWeKnow: string;
+    whyItMatters: string;
+    confidence: "high" | "low" | "medium";
+    evidenceRefs: string[];
+  }>;
+  riskPosture: Array<{
+    id: string;
+    level: "critical" | "high" | "medium";
+    title: string;
+    message: string;
+    mitigation: string;
+    evidenceRefs: string[];
+  }>;
+  dataGaps: Array<{
+    id: string;
+    title: string;
+    priority: "high" | "low" | "medium";
+    owner: "ai_layer" | "external_service" | "product_review";
+    whyItBlocks: string;
+    nextStep: string;
+  }>;
+  blockedActions: string[];
+  summary: string;
+  nextActions: string[];
+};
+
+export type StrategyQualityReviewContract = {
+  schemaVersion: "seo-strategy-quality-review.v1";
+  projectId: string;
+  semanticRunId: string | null;
+  runId: string | null;
+  generatedAt: string;
+  state: "not_ready" | "ready";
+  provider: {
+    mode: "codex_manual" | "deterministic_fallback";
+    modelRequired: true;
+    message: string;
+  };
+  sourceTaskId: string | null;
+  sourceStrategyGeneratedAt: string | null;
+  sourceStrategySynthesisRunId: string | null;
+  sourceSerpInterpretationRunId: string | null;
+  analystReview: {
+    status: "approved" | "needs_changes" | "not_reviewed" | "rejected";
+    reviewer: "codex" | "human" | "system";
+    reviewedAt: string | null;
+    notes: string[];
+  };
+  verdict: {
+    status: "approved" | "blocked" | "needs_changes";
+    title: string;
+    summary: string;
+    confidence: "high" | "low" | "medium";
+    score: number;
+    primaryBlocker: string | null;
+  };
+  readiness: {
+    score: number;
+    approvedSignalCount: number;
+    blockerCount: number;
+    checkCount: number;
+    evidenceRefIssueCount: number;
+    hallucinationRiskCount: number;
+    issueCount: number;
+    passedCount: number;
+    phaseGuardrailIssueCount: number;
+    warningCount: number;
+    uxIssueCount: number;
+  };
+  checks: Array<{
+    id: string;
+    category:
+      | "business_drift"
+      | "evidence_integrity"
+      | "hallucination_guardrail"
+      | "phase_guardrail"
+      | "source_safety"
+      | "ux_clarity";
+    status: "fail" | "pass" | "warning";
+    severity: "critical" | "high" | "low" | "medium";
+    title: string;
+    message: string;
+    action: string;
+    evidenceRefs: string[];
+  }>;
+  blockers: string[];
+  warnings: string[];
+  approvedSignals: string[];
+  summary: string;
+  nextActions: string[];
+};
+
+export type RewritePlanContract = {
+  schemaVersion: "rewrite-plan.v1";
+  projectId: string;
+  semanticRunId: string | null;
+  projectOntologyVersionId: string | null;
+  generatedAt: string;
+  state: "blocked" | "materialization_required" | "partial_ready" | "ready_for_diff";
+  readiness: {
+    approvedDecisionCount: number;
+    existingPageTargetCount: number;
+    plannedLandingTargetCount: number;
+    rewriteCandidateCount: number;
+    blockerCount: number;
+  };
+  blockers: string[];
+  existingPageTargets: RewritePlanTarget[];
+  materializationQueue: RewritePlanTarget[];
+  nextActions: string[];
+};
+
+export type RewritePlanTarget = {
+  id: string;
+  targetPath: string | null;
+  pageId: string | null;
+  pageTitle: string | null;
+  sourcePath: string | null;
+  urlPath: string | null;
+  status: "needs_materialization" | "planned_placeholder" | "ready_for_diff";
+  blocker: string | null;
+  keywordBindings: Array<{
+    decisionId: string;
+    mapItemId: string | null;
+    phrase: string;
+    role: string;
+    field: "body_section" | "h1" | "meta_description" | "title";
+    clusterId: string | null;
+    clusterTitle: string | null;
+    evidenceStatus: string | null;
+    frequency: number | null;
+    frequencyGroup: string | null;
+    workspaceSectionId: string | null;
+    exactLimit: number | null;
+    approvedAt: string;
+    instruction: string;
+  }>;
+};
+
+export type MaterializationContract = {
+  schemaVersion: "materialization-contract.v1";
+  projectId: string;
+  semanticRunId: string | null;
+  projectOntologyVersionId: string | null;
+  generatedAt: string;
+  state: "blocked" | "complete" | "partial" | "pending";
+  rewritePlanState: RewritePlanContract["state"];
+  readiness: {
+    awaitingSourceCount: number;
+    blockerCount: number;
+    linkedTargetCount: number;
+    pendingTargetCount: number;
+    placeholderTargetCount: number;
+    rejectedOrDeferredCount: number;
+    targetCount: number;
+  };
+  blockers: string[];
+  targets: Array<{
+    id: string;
+    targetKey: string;
+    targetPath: string | null;
+    normalizedTargetPath: string | null;
+    status:
+      | "awaiting_source"
+      | "can_link_existing"
+      | "deferred"
+      | "linked_existing"
+      | "needs_materialization"
+      | "planned_placeholder"
+      | "rejected";
+    pageId: string | null;
+    pageTitle: string | null;
+    sourcePath: string | null;
+    urlPath: string | null;
+    blocker: string | null;
+    sourcePlan: {
+      action: "create_source_snapshot" | "link_existing_page" | "manual_review";
+      reason: string;
+      requiresApproval: boolean;
+      sourceType: string | null;
+      status: "approval_required" | "can_link_existing" | "manual_review" | "source_approved";
+      suggestedSourcePath: string | null;
+    };
+    decision: {
+      id: string;
+      action: "approve_source_plan" | "create_placeholder" | "defer" | "link_existing_page" | "reject";
+      note: string | null;
+      sourcePath: string | null;
+      updatedAt: string;
+    } | null;
+    linkCandidates: Array<{
+      pageId: string;
+      sourcePath: string;
+      urlPath: string | null;
+      title: string | null;
+      selected: boolean;
+      match: "exact" | "home" | "selected";
+    }>;
+    keywordBindings: Array<{
+      decisionId: string;
+      mapItemId: string | null;
+      phrase: string;
+      role: string;
+      field: string;
+      frequency: number | null;
+      frequencyGroup: string | null;
+    }>;
+  }>;
+  nextActions: string[];
+};
+
+export type MaterializationActionInput =
+  | {
+      action: "approve_source_plan";
+      note?: string;
+      sourcePath: string;
+      targetPath: string;
+    }
+  | {
+      action: "create_placeholder";
+      note?: string;
+      targetPath: string;
+      title?: string;
+    }
+  | {
+      action: "defer";
+      note?: string;
+      targetPath: string;
+    }
+  | {
+      action: "link_existing_page";
+      note?: string;
+      pageId: string;
+      targetPath: string;
+    }
+  | {
+      action: "reject";
+      note?: string;
+      targetPath: string;
+    };
+
+export type RewriteDiffContract = {
+  schemaVersion: "rewrite-diff.v1";
+  projectId: string;
+  semanticRunId: string | null;
+  projectOntologyVersionId: string | null;
+  generatedAt: string;
+  state: "blocked" | "materialization_required" | "partial_ready" | "ready_for_model_review";
+  readiness: {
+    blockerCount: number;
+    materializationTargetCount: number;
+    modelReadySlotCount: number;
+    sourcePendingSlotCount: number;
+    slotCount: number;
+    targetCount: number;
+  };
+  blockers: string[];
+  targets: Array<{
+    id: string;
+    pageId: string;
+    pageTitle: string | null;
+    sourcePath: string | null;
+    urlPath: string | null;
+    status: "ready_for_model_review" | "source_pending";
+    slots: Array<{
+      id: string;
+      field: "body_section" | "h1" | "meta_description" | "title";
+      workspaceSectionId: string | null;
+      status: "ready_for_model_review" | "source_pending";
+      source: "missing_source" | "page_version" | "workspace_snapshot";
+      currentValue: string | null;
+      proposedValue: null;
+      blockers: string[];
+      instruction: string;
+      keywordBindings: Array<{
+        decisionId: string;
+        phrase: string;
+        role: string;
+        frequency: number | null;
+        frequencyGroup: string | null;
+        exactLimit: number | null;
+      }>;
+    }>;
+  }>;
+  nextActions: string[];
+};
+
 export type ExternalServiceSettings = {
   schemaVersion: "external-service-settings.v1";
   services: Array<{
@@ -597,6 +1833,33 @@ export type ExternalServiceUpdateInput = {
   secrets?: Record<string, string>;
 };
 
+export type YandexAiStudioProbe = {
+  schemaVersion: "yandex-ai-studio-probe.v1";
+  checkedAt: string;
+  phrase: string;
+  credential:
+    | {
+        configured: false;
+        provider: "disabled" | "mcp_kv";
+      }
+    | {
+        configured: true;
+        provider: "yandex_api";
+        authType: "api_key" | "iam_token";
+        folderId: string;
+      };
+  capabilities: Array<{
+    id: "wordstat_top" | "wordstat_regions" | "wordstat_dynamics" | "web_search";
+    label: string;
+    ok: boolean;
+    status: number | null;
+    ms: number;
+    summary: string;
+    sample: unknown;
+    error: string | null;
+  }>;
+};
+
 export type PageWorkspace = {
   projectId: string;
   pageId: string;
@@ -823,6 +2086,59 @@ export async function runSemanticAnalysis(projectId: string) {
   return response.json() as Promise<{ analysis: SemanticAnalysisRun }>;
 }
 
+export async function fetchLatestProjectOntology(projectId: string) {
+  const response = await fetch(`${apiBaseUrl}/projects/${projectId}/ontology/latest`);
+
+  if (!response.ok) {
+    throw new Error(await getErrorMessage(response, `Не удалось загрузить project ontology: ${response.status}`));
+  }
+
+  return response.json() as Promise<{ ontology: ProjectOntologyVersion | null }>;
+}
+
+export async function updateProjectOntologyApproval(
+  projectId: string,
+  versionId: string,
+  status: ProjectOntologyApprovalStatus
+) {
+  const response = await fetch(`${apiBaseUrl}/projects/${projectId}/ontology/${versionId}/approval`, {
+    method: "PATCH",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ status })
+  });
+
+  if (!response.ok) {
+    throw new Error(await getErrorMessage(response, `Не удалось обновить project ontology: ${response.status}`));
+  }
+
+  return response.json() as Promise<{ ontology: ProjectOntologyVersion }>;
+}
+
+export async function updateProjectOntologyConfirmations(
+  projectId: string,
+  versionId: string,
+  input: {
+    aliasesConfirmed?: boolean;
+    brandConfirmed?: boolean;
+  }
+) {
+  const response = await fetch(`${apiBaseUrl}/projects/${projectId}/ontology/${versionId}/confirmations`, {
+    method: "PATCH",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(input)
+  });
+
+  if (!response.ok) {
+    throw new Error(await getErrorMessage(response, `Не удалось обновить confirmations project ontology: ${response.status}`));
+  }
+
+  return response.json() as Promise<{ ontology: ProjectOntologyVersion }>;
+}
+
 function getFilenameFromContentDisposition(value: string | null, fallback: string) {
   if (!value) {
     return fallback;
@@ -849,7 +2165,7 @@ export async function downloadSemanticAnalysisExport(projectId: string, format:
     blob: await response.blob(),
     filename: getFilenameFromContentDisposition(
       response.headers.get("Content-Disposition"),
-      `nodedc-seo-export.${extensions[format]}`
+      `seo-analysis-export.${extensions[format]}`
     )
   };
 }
@@ -864,6 +2180,129 @@ export async function fetchLatestMarketEnrichment(projectId: string) {
   return response.json() as Promise<{ marketEnrichment: MarketEnrichmentContract }>;
 }
 
+export async function fetchLatestSeoContextReview(projectId: string) {
+  const response = await fetch(`${apiBaseUrl}/projects/${projectId}/context-review/latest`);
+
+  if (!response.ok) {
+    throw new Error(await getErrorMessage(response, `Не удалось загрузить context review: ${response.status}`));
+  }
+
+  return response.json() as Promise<{ contextReview: SeoContextReviewRun | null }>;
+}
+
+export async function runSeoContextReview(projectId: string) {
+  const response = await fetch(`${apiBaseUrl}/projects/${projectId}/context-review`, {
+    method: "POST"
+  });
+
+  if (!response.ok) {
+    throw new Error(await getErrorMessage(response, `Не удалось выполнить context review: ${response.status}`));
+  }
+
+  return response.json() as Promise<{ contextReview: SeoContextReviewRun }>;
+}
+
+export async function saveManualSeoContextReview(projectId: string, output: Record<string, unknown>) {
+  const response = await fetch(`${apiBaseUrl}/projects/${projectId}/context-review/manual`, {
+    body: JSON.stringify({ output }),
+    headers: {
+      "Content-Type": "application/json"
+    },
+    method: "POST"
+  });
+
+  if (!response.ok) {
+    throw new Error(await getErrorMessage(response, `Не удалось сохранить manual context review: ${response.status}`));
+  }
+
+  return response.json() as Promise<{ contextReview: SeoContextReviewRun }>;
+}
+
+export async function fetchModelProviderStatus(projectId: string) {
+  const response = await fetch(`${apiBaseUrl}/projects/${projectId}/model-provider/status`);
+
+  if (!response.ok) {
+    throw new Error(await getErrorMessage(response, `Не удалось загрузить model provider status: ${response.status}`));
+  }
+
+  return response.json() as Promise<{ modelProvider: SeoModelProviderStatusContract }>;
+}
+
+export async function runSeoModelTask(
+  projectId: string,
+  input: {
+    providerId?: SeoModelProviderId;
+    taskId?: string;
+    taskType?: SeoModelTaskType;
+  }
+) {
+  const response = await fetch(`${apiBaseUrl}/projects/${projectId}/model-tasks/run`, {
+    body: JSON.stringify(input),
+    headers: {
+      "Content-Type": "application/json"
+    },
+    method: "POST"
+  });
+
+  if (!response.ok) {
+    throw new Error(await getErrorMessage(response, `Не удалось выполнить model task run: ${response.status}`));
+  }
+
+  return response.json() as Promise<{ modelTaskRun: SeoModelTaskRun }>;
+}
+
+export async function fetchLatestSeoNormalization(projectId: string) {
+  const response = await fetch(`${apiBaseUrl}/projects/${projectId}/seo-normalization/latest`);
+
+  if (!response.ok) {
+    throw new Error(await getErrorMessage(response, `Не удалось загрузить SEO normalization: ${response.status}`));
+  }
+
+  return response.json() as Promise<{ normalization: SeoNormalizationContract }>;
+}
+
+export async function saveManualSeoNormalization(projectId: string, output: Record<string, unknown>) {
+  const response = await fetch(`${apiBaseUrl}/projects/${projectId}/seo-normalization/manual`, {
+    body: JSON.stringify({ output }),
+    headers: {
+      "Content-Type": "application/json"
+    },
+    method: "POST"
+  });
+
+  if (!response.ok) {
+    throw new Error(await getErrorMessage(response, `Не удалось сохранить manual SEO normalization: ${response.status}`));
+  }
+
+  return response.json() as Promise<{ normalization: SeoNormalizationContract }>;
+}
+
+export async function fetchLatestKeywordCleaning(projectId: string) {
+  const response = await fetch(`${apiBaseUrl}/projects/${projectId}/keyword-cleaning/latest`);
+
+  if (!response.ok) {
+    throw new Error(await getErrorMessage(response, `Не удалось загрузить keyword cleaning: ${response.status}`));
+  }
+
+  return response.json() as Promise<{ keywordCleaning: KeywordCleaningContract }>;
+}
+
+export async function saveManualKeywordCleaning(projectId: string, output: Record<string, unknown>) {
+  const response = await fetch(`${apiBaseUrl}/projects/${projectId}/keyword-cleaning/manual`, {
+    body: JSON.stringify({ output }),
+    headers: {
+      "Content-Type": "application/json"
+    },
+    method: "POST"
+  });
+
+  if (!response.ok) {
+    throw new Error(await getErrorMessage(response, `Не удалось сохранить manual keyword cleaning: ${response.status}`));
+  }
+
+  return response.json() as Promise<{ keywordCleaning: KeywordCleaningContract }>;
+}
+
 export async function runMarketEnrichment(projectId: string) {
   const response = await fetch(`${apiBaseUrl}/projects/${projectId}/market-enrichment`, {
     method: "POST"
@@ -876,6 +2315,189 @@ export async function runMarketEnrichment(projectId: string) {
   return response.json() as Promise<{ marketEnrichment: MarketEnrichmentContract }>;
 }
 
+export async function fetchLatestYandexEvidence(projectId: string) {
+  const response = await fetch(`${apiBaseUrl}/projects/${projectId}/yandex-evidence/latest`);
+
+  if (!response.ok) {
+    throw new Error(await getErrorMessage(response, `Не удалось загрузить Yandex evidence: ${response.status}`));
+  }
+
+  return response.json() as Promise<{ yandexEvidence: YandexEvidenceContract }>;
+}
+
+export async function runYandexEvidence(projectId: string, phraseLimit = 5) {
+  const response = await fetch(`${apiBaseUrl}/projects/${projectId}/yandex-evidence`, {
+    body: JSON.stringify({ phraseLimit }),
+    headers: {
+      "Content-Type": "application/json"
+    },
+    method: "POST"
+  });
+
+  if (!response.ok) {
+    throw new Error(await getErrorMessage(response, `Не удалось собрать Yandex evidence: ${response.status}`));
+  }
+
+  return response.json() as Promise<{ yandexEvidence: YandexEvidenceContract }>;
+}
+
+export async function fetchLatestSerpInterpretation(projectId: string) {
+  const response = await fetch(`${apiBaseUrl}/projects/${projectId}/serp-interpretation/latest`);
+
+  if (!response.ok) {
+    throw new Error(await getErrorMessage(response, `Не удалось загрузить SERP interpretation: ${response.status}`));
+  }
+
+  return response.json() as Promise<{ serpInterpretation: SerpInterpretationContract }>;
+}
+
+export async function runSerpInterpretation(projectId: string) {
+  const response = await fetch(`${apiBaseUrl}/projects/${projectId}/serp-interpretation`, {
+    method: "POST"
+  });
+
+  if (!response.ok) {
+    throw new Error(await getErrorMessage(response, `Не удалось собрать SERP interpretation: ${response.status}`));
+  }
+
+  return response.json() as Promise<{ serpInterpretation: SerpInterpretationContract }>;
+}
+
+export async function fetchLatestKeywordMap(projectId: string) {
+  const response = await fetch(`${apiBaseUrl}/projects/${projectId}/keyword-map/latest`);
+
+  if (!response.ok) {
+    throw new Error(await getErrorMessage(response, `Не удалось загрузить keyword map: ${response.status}`));
+  }
+
+  return response.json() as Promise<{ keywordMap: KeywordMapContract }>;
+}
+
+export async function fetchLatestSeoStrategy(projectId: string) {
+  const response = await fetch(`${apiBaseUrl}/projects/${projectId}/strategy/latest`);
+
+  if (!response.ok) {
+    throw new Error(await getErrorMessage(response, `Не удалось загрузить SEO strategy: ${response.status}`));
+  }
+
+  return response.json() as Promise<{ strategy: SeoStrategyContract }>;
+}
+
+export async function fetchLatestStrategySynthesis(projectId: string) {
+  const response = await fetch(`${apiBaseUrl}/projects/${projectId}/strategy-synthesis/latest`);
+
+  if (!response.ok) {
+    throw new Error(await getErrorMessage(response, `Не удалось загрузить strategy synthesis: ${response.status}`));
+  }
+
+  return response.json() as Promise<{ strategySynthesis: StrategySynthesisContract }>;
+}
+
+export async function runStrategySynthesis(projectId: string) {
+  const response = await fetch(`${apiBaseUrl}/projects/${projectId}/strategy-synthesis`, {
+    method: "POST"
+  });
+
+  if (!response.ok) {
+    throw new Error(await getErrorMessage(response, `Не удалось собрать strategy synthesis: ${response.status}`));
+  }
+
+  return response.json() as Promise<{ strategySynthesis: StrategySynthesisContract }>;
+}
+
+export async function fetchLatestStrategyQualityReview(projectId: string) {
+  const response = await fetch(`${apiBaseUrl}/projects/${projectId}/strategy-quality-review/latest`);
+
+  if (!response.ok) {
+    throw new Error(await getErrorMessage(response, `Не удалось загрузить strategy quality review: ${response.status}`));
+  }
+
+  return response.json() as Promise<{ strategyQualityReview: StrategyQualityReviewContract }>;
+}
+
+export async function runStrategyQualityReview(projectId: string) {
+  const response = await fetch(`${apiBaseUrl}/projects/${projectId}/strategy-quality-review`, {
+    method: "POST"
+  });
+
+  if (!response.ok) {
+    throw new Error(await getErrorMessage(response, `Не удалось собрать strategy quality review: ${response.status}`));
+  }
+
+  return response.json() as Promise<{ strategyQualityReview: StrategyQualityReviewContract }>;
+}
+
+export async function approveKeywordMapDecisions(projectId: string, itemIds?: string[]) {
+  const response = await fetch(`${apiBaseUrl}/projects/${projectId}/keyword-map/decisions`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ itemIds })
+  });
+
+  if (!response.ok) {
+    throw new Error(await getErrorMessage(response, `Не удалось сохранить keyword decisions: ${response.status}`));
+  }
+
+  return response.json() as Promise<{
+    keywordMap: KeywordMapContract;
+    savedDecisionCount: number;
+    savedMapItemCount: number;
+    skippedItemCount: number;
+  }>;
+}
+
+export async function fetchLatestRewritePlan(projectId: string) {
+  const response = await fetch(`${apiBaseUrl}/projects/${projectId}/rewrite-plan/latest`);
+
+  if (!response.ok) {
+    throw new Error(await getErrorMessage(response, `Не удалось загрузить rewrite plan: ${response.status}`));
+  }
+
+  return response.json() as Promise<{ rewritePlan: RewritePlanContract }>;
+}
+
+export async function fetchLatestMaterialization(projectId: string) {
+  const response = await fetch(`${apiBaseUrl}/projects/${projectId}/materialization/latest`);
+
+  if (!response.ok) {
+    throw new Error(await getErrorMessage(response, `Не удалось загрузить materialization contract: ${response.status}`));
+  }
+
+  return response.json() as Promise<{ materialization: MaterializationContract }>;
+}
+
+export async function applyMaterializationAction(projectId: string, input: MaterializationActionInput) {
+  const response = await fetch(`${apiBaseUrl}/projects/${projectId}/materialization/actions`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(input)
+  });
+
+  if (!response.ok) {
+    throw new Error(await getErrorMessage(response, `Не удалось применить materialization action: ${response.status}`));
+  }
+
+  return response.json() as Promise<{
+    materialization: MaterializationContract;
+    rewritePlan: RewritePlanContract;
+    updatedMapItemCount: number;
+  }>;
+}
+
+export async function fetchLatestRewriteDiff(projectId: string) {
+  const response = await fetch(`${apiBaseUrl}/projects/${projectId}/rewrite-diff/latest`);
+
+  if (!response.ok) {
+    throw new Error(await getErrorMessage(response, `Не удалось загрузить rewrite diff contract: ${response.status}`));
+  }
+
+  return response.json() as Promise<{ rewriteDiff: RewriteDiffContract }>;
+}
+
 export async function fetchExternalServiceSettings() {
   const response = await fetch(`${apiBaseUrl}/settings/external-services`);
 
@@ -905,6 +2527,22 @@ export async function updateExternalServiceSettings(
   return response.json() as Promise<{ service: ExternalServiceSettings["services"][number] }>;
 }
 
+export async function probeYandexAiStudioCredential(phrase?: string) {
+  const response = await fetch(`${apiBaseUrl}/settings/external-services/yandex_cloud/probe`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ phrase })
+  });
+
+  if (!response.ok) {
+    throw new Error(await getErrorMessage(response, `Не удалось проверить Yandex AI Studio: ${response.status}`));
+  }
+
+  return response.json() as Promise<{ probe: YandexAiStudioProbe }>;
+}
+
 export async function updateProjectPageSelection(projectId: string, pageIds: string[], selected: boolean) {
   const response = await fetch(`${apiBaseUrl}/projects/${projectId}/pages/selection`, {
     method: "PATCH",
diff --git a/seo_mode/seo_mode/app/src/styles.css b/seo_mode/seo_mode/app/src/styles.css
index 574418e..f9e0b16 100644
--- a/seo_mode/seo_mode/app/src/styles.css
+++ b/seo_mode/seo_mode/app/src/styles.css
@@ -514,6 +514,70 @@ input {
 .service-card-footer {
   align-items: center;
   padding-top: 2px;
+  flex-wrap: wrap;
+}
+
+.service-probe-result {
+  display: grid;
+  gap: 8px;
+  padding: 10px;
+  background: rgba(46, 73, 96, 0.04);
+  border: 1px solid var(--line);
+  border-radius: 8px;
+}
+
+.service-probe-result > div {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 10px;
+}
+
+.service-probe-result strong,
+.service-probe-result span {
+  color: var(--ink);
+  font-size: 12px;
+  font-weight: 900;
+}
+
+.service-probe-result span {
+  color: var(--muted);
+}
+
+.service-probe-result ul {
+  display: grid;
+  gap: 6px;
+  margin: 0;
+  padding: 0;
+  list-style: none;
+}
+
+.service-probe-result li {
+  display: grid;
+  gap: 2px;
+  padding: 7px 8px;
+  background: #fff;
+  border: 1px solid var(--line);
+  border-radius: 7px;
+}
+
+.service-probe-result li span {
+  color: var(--ink);
+}
+
+.service-probe-result li small {
+  color: var(--muted);
+  font-size: 11px;
+  font-weight: 760;
+  line-height: 1.35;
+}
+
+.service-probe-result li.ok {
+  border-color: rgba(47, 107, 79, 0.2);
+}
+
+.service-probe-result li.error {
+  border-color: rgba(139, 47, 47, 0.2);
 }
 
 .status-pill {
@@ -1721,6 +1785,344 @@ input {
   font-weight: 750;
 }
 
+.semantic-review-summary {
+  display: grid;
+  grid-template-columns: repeat(4, minmax(0, 1fr));
+  gap: 8px;
+}
+
+.semantic-review-card {
+  display: grid;
+  align-content: start;
+  gap: 5px;
+  min-height: 112px;
+  padding: 10px;
+  background: #fff;
+  border: 1px solid rgba(24, 32, 29, 0.1);
+  border-radius: 8px;
+}
+
+.semantic-review-card.semantic-context-card {
+  grid-column: span 2;
+}
+
+.semantic-context-summary {
+  display: grid;
+  grid-template-columns: minmax(220px, 0.5fr) minmax(0, 1fr);
+  gap: 12px;
+  align-items: start;
+  padding: 14px;
+  background: #fff;
+  border: 1px solid rgba(24, 32, 29, 0.1);
+  border-radius: 18px;
+}
+
+.semantic-context-summary > div:first-child {
+  display: grid;
+  gap: 5px;
+  min-width: 0;
+}
+
+.semantic-context-summary strong {
+  color: var(--ink);
+  font-size: 14px;
+}
+
+.semantic-context-summary small {
+  color: var(--muted);
+  font-size: 12px;
+  font-weight: 740;
+  line-height: 1.38;
+}
+
+.semantic-context-tags {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 6px;
+  min-width: 0;
+}
+
+.semantic-context-tags span {
+  display: inline-flex;
+  max-width: 100%;
+  min-height: 26px;
+  align-items: center;
+  padding: 0 9px;
+  color: #33413c;
+  background: rgba(24, 32, 29, 0.055);
+  border: 1px solid rgba(24, 32, 29, 0.08);
+  border-radius: 999px;
+  font-size: 11px;
+  font-weight: 850;
+  line-height: 1.15;
+}
+
+.seo-context-review-card,
+.market-context-gate {
+  display: flex;
+  gap: 10px;
+  align-items: center;
+  justify-content: space-between;
+  padding: 10px;
+  background: #fff;
+  border: 1px solid var(--line);
+  border-radius: 8px;
+}
+
+.seo-context-review-card.warning,
+.market-context-gate {
+  border-color: rgba(178, 119, 31, 0.32);
+  background: rgba(178, 119, 31, 0.055);
+}
+
+.seo-context-review-card.ready {
+  border-color: rgba(47, 107, 79, 0.24);
+}
+
+.seo-context-review-card.stale,
+.seo-context-review-card.missing {
+  border-color: rgba(139, 47, 47, 0.24);
+}
+
+.seo-context-review-card > div:first-child,
+.market-context-gate > div:first-child {
+  display: grid;
+  gap: 4px;
+  min-width: 0;
+}
+
+.seo-context-review-card span,
+.market-context-gate span {
+  color: #2e5a67;
+  font-size: 11px;
+  font-weight: 900;
+  text-transform: uppercase;
+}
+
+.seo-context-review-card strong,
+.market-context-gate strong {
+  color: var(--ink);
+  font-size: 13px;
+}
+
+.seo-context-review-card small,
+.market-context-gate small {
+  color: var(--muted);
+  font-size: 12px;
+  font-weight: 740;
+  line-height: 1.38;
+}
+
+.seo-context-review-metrics {
+  display: flex;
+  flex: 0 1 auto;
+  flex-wrap: wrap;
+  justify-content: flex-end;
+  gap: 6px;
+  min-width: 160px;
+}
+
+.seo-context-review-metrics span {
+  display: inline-flex;
+  min-height: 22px;
+  align-items: center;
+  padding: 0 8px;
+  background: rgba(46, 90, 103, 0.08);
+  border: 1px solid rgba(46, 90, 103, 0.12);
+  border-radius: 999px;
+  color: #2e5a67;
+  font-size: 11px;
+  font-weight: 900;
+  text-transform: none;
+  white-space: nowrap;
+}
+
+.model-provider-panel {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) minmax(220px, 0.38fr) auto;
+  gap: 10px;
+  align-items: center;
+  padding: 10px;
+  background: #fff;
+  border: 1px solid var(--line);
+  border-radius: 8px;
+}
+
+.model-provider-panel.not_configured,
+.model-provider-panel.planned,
+.model-provider-panel.missing {
+  border-color: rgba(178, 119, 31, 0.26);
+  background: rgba(178, 119, 31, 0.045);
+}
+
+.model-provider-panel > div:first-child,
+.model-provider-run {
+  display: grid;
+  gap: 4px;
+  min-width: 0;
+}
+
+.model-provider-panel span {
+  color: #2e5a67;
+  font-size: 11px;
+  font-weight: 900;
+  text-transform: uppercase;
+}
+
+.model-provider-panel strong {
+  min-width: 0;
+  overflow-wrap: anywhere;
+  color: var(--ink);
+  font-size: 13px;
+}
+
+.model-provider-panel small {
+  min-width: 0;
+  overflow-wrap: anywhere;
+  color: var(--muted);
+  font-size: 12px;
+  font-weight: 740;
+  line-height: 1.38;
+}
+
+.model-provider-actions {
+  display: flex;
+  flex-wrap: wrap;
+  justify-content: flex-end;
+  gap: 8px;
+}
+
+@media (max-width: 980px) {
+  .model-provider-panel {
+    grid-template-columns: 1fr;
+  }
+
+  .model-provider-actions {
+    justify-content: flex-start;
+  }
+}
+
+.semantic-review-card.ok {
+  border-color: rgba(47, 107, 79, 0.18);
+}
+
+.semantic-review-card.warning {
+  border-color: rgba(155, 111, 39, 0.22);
+}
+
+.semantic-review-card.problem {
+  border-color: rgba(139, 47, 47, 0.22);
+}
+
+.semantic-review-card span,
+.semantic-review-next span,
+.semantic-dev-details summary > span {
+  width: fit-content;
+  padding: 3px 7px;
+  color: #2e5a67;
+  background: rgba(46, 90, 103, 0.08);
+  border: 1px solid rgba(24, 32, 29, 0.1);
+  border-radius: 999px;
+  font-size: 10px;
+  font-weight: 900;
+  text-transform: uppercase;
+}
+
+.semantic-review-card strong,
+.semantic-review-next strong,
+.semantic-dev-details summary strong {
+  min-width: 0;
+  color: #18201d;
+  font-size: 13px;
+  overflow-wrap: anywhere;
+}
+
+.semantic-review-card small,
+.semantic-review-next small,
+.semantic-dev-details summary small {
+  min-width: 0;
+  color: #6d7c76;
+  font-size: 12px;
+  font-weight: 740;
+  line-height: 1.38;
+  overflow-wrap: anywhere;
+}
+
+.semantic-review-next {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) minmax(180px, 0.9fr);
+  gap: 10px;
+  align-items: center;
+  padding: 10px;
+  background: #fff;
+  border: 1px solid rgba(24, 32, 29, 0.1);
+  border-radius: 8px;
+}
+
+.semantic-review-next > div {
+  display: grid;
+  gap: 5px;
+  min-width: 0;
+}
+
+.semantic-review-next > div:last-child {
+  display: flex;
+  flex-wrap: wrap;
+  justify-content: flex-end;
+  gap: 6px;
+}
+
+.semantic-dev-details {
+  display: grid;
+  gap: 10px;
+  padding: 12px;
+  background: rgba(255, 255, 255, 0.72);
+  border: 1px solid rgba(24, 32, 29, 0.1);
+  border-radius: 18px;
+}
+
+.semantic-dev-details summary {
+  display: grid;
+  grid-template-columns: auto minmax(0, 1fr) auto;
+  gap: 5px 10px;
+  align-items: center;
+  cursor: pointer;
+  list-style: none;
+}
+
+.semantic-dev-details summary::after {
+  content: "+";
+  display: grid;
+  width: 24px;
+  height: 24px;
+  place-items: center;
+  color: var(--muted);
+  background: rgba(24, 32, 29, 0.06);
+  border-radius: 999px;
+  font-size: 15px;
+  font-weight: 900;
+  line-height: 1;
+}
+
+.semantic-dev-details[open] summary::after {
+  content: "-";
+}
+
+.semantic-dev-details summary::-webkit-details-marker {
+  display: none;
+}
+
+.semantic-dev-details summary small {
+  grid-column: 2;
+}
+
+.semantic-dev-details-body {
+  display: grid;
+  gap: 12px;
+  padding-top: 10px;
+  border-top: 1px solid rgba(24, 32, 29, 0.08);
+}
+
 .semantic-score-grid {
   display: grid;
   grid-template-columns: minmax(120px, 0.28fr) minmax(0, 1fr);
@@ -1843,6 +2245,25 @@ input {
   gap: 8px;
 }
 
+.semantic-chip-list {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 6px;
+  margin-top: 8px;
+}
+
+.semantic-chip-list span {
+  display: inline-flex;
+  align-items: center;
+  min-height: 24px;
+  padding: 0 8px;
+  color: #2e5a67;
+  background: rgba(46, 90, 103, 0.1);
+  border-radius: 999px;
+  font-size: 11px;
+  font-weight: 900;
+}
+
 .semantic-quality {
   display: grid;
   grid-template-columns: auto minmax(0, 1fr);
@@ -2112,20 +2533,80 @@ input {
 .market-heading,
 .market-state-card,
 .market-wordstat-card,
-.market-provider {
+.market-provider,
+.market-normalization-card {
   display: flex;
   justify-content: space-between;
   gap: 10px;
 }
 
-.market-heading {
+.market-heading,
+.market-normalization-card {
   align-items: flex-start;
 }
 
+.stage-decision-frame {
+  display: grid;
+  grid-template-columns: auto minmax(0, 1fr) minmax(180px, 0.7fr);
+  gap: 10px;
+  align-items: center;
+  padding: 10px;
+  background: #fff;
+  border: 1px solid var(--line);
+  border-radius: 8px;
+}
+
+.stage-decision-frame > span {
+  justify-self: start;
+  padding: 4px 8px;
+  color: #2e5a67;
+  background: rgba(46, 90, 103, 0.08);
+  border: 1px solid var(--line);
+  border-radius: 999px;
+  font-size: 11px;
+  font-weight: 900;
+  white-space: nowrap;
+}
+
+.stage-decision-frame div {
+  display: grid;
+  gap: 4px;
+  min-width: 0;
+}
+
+.stage-decision-frame strong,
+.stage-decision-frame small,
+.stage-decision-frame p {
+  min-width: 0;
+  margin: 0;
+  overflow-wrap: anywhere;
+}
+
+.stage-decision-frame strong {
+  color: var(--ink);
+  font-size: 13px;
+}
+
+.stage-decision-frame small,
+.stage-decision-frame p {
+  color: var(--muted);
+  font-size: 12px;
+  font-weight: 740;
+  line-height: 1.38;
+}
+
+@media (max-width: 760px) {
+  .stage-decision-frame {
+    grid-template-columns: 1fr;
+    align-items: start;
+  }
+}
+
 .market-heading > div,
 .market-state-card > div,
 .market-wordstat-card > div,
 .market-provider > div,
+.market-normalization-card > div:first-child,
 .market-columns section,
 .market-next-actions {
   display: grid;
@@ -2137,6 +2618,7 @@ input {
 .market-state-card strong,
 .market-wordstat-card strong,
 .market-provider strong,
+.market-normalization-card strong,
 .market-columns strong,
 .market-next-actions strong {
   color: var(--ink);
@@ -2149,6 +2631,8 @@ input {
 .market-wordstat-card p,
 .market-provider small,
 .market-provider p,
+.market-normalization-card small,
+.market-normalization-card p,
 .market-columns small,
 .market-next-actions p {
   margin: 0;
@@ -2166,6 +2650,168 @@ input {
   border-radius: 8px;
 }
 
+.market-normalization-card {
+  flex-wrap: wrap;
+  padding: 10px;
+  background: rgba(255, 255, 255, 0.88);
+  border: 1px solid var(--line);
+  border-radius: 8px;
+}
+
+.market-normalization-card > div:first-child {
+  flex: 1 1 360px;
+}
+
+.market-normalization-card > p {
+  flex-basis: 100%;
+}
+
+.market-normalization-card > div:first-child > span {
+  justify-self: start;
+  min-height: 22px;
+  display: inline-flex;
+  align-items: center;
+  padding: 0 9px;
+  color: #2e5a67;
+  background: rgba(46, 90, 103, 0.08);
+  border: 1px solid rgba(46, 90, 103, 0.14);
+  border-radius: 999px;
+  font-size: 11px;
+  font-weight: 900;
+}
+
+.market-normalization-stats {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 6px;
+}
+
+.market-normalization-stats span {
+  min-height: 24px;
+  display: inline-flex;
+  align-items: center;
+  padding: 0 8px;
+  color: #2e4960;
+  background: rgba(46, 73, 96, 0.06);
+  border: 1px solid rgba(46, 73, 96, 0.08);
+  border-radius: 999px;
+  font-size: 11px;
+  font-weight: 900;
+  white-space: nowrap;
+}
+
+.market-normalization-groups {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 8px;
+  width: min(560px, 48%);
+  min-width: 360px;
+}
+
+.market-normalization-groups article {
+  display: grid;
+  gap: 4px;
+  min-width: 0;
+  padding: 9px;
+  background: rgba(24, 32, 29, 0.035);
+  border: 1px solid rgba(24, 32, 29, 0.06);
+  border-radius: 8px;
+}
+
+.market-normalization-groups span {
+  justify-self: start;
+  min-height: 18px;
+  display: inline-flex;
+  align-items: center;
+  padding: 0 7px;
+  color: var(--muted);
+  background: rgba(24, 32, 29, 0.055);
+  border-radius: 999px;
+  font-size: 10px;
+  font-weight: 860;
+}
+
+.market-normalization-review {
+  display: grid;
+  grid-template-columns: repeat(4, minmax(0, 1fr));
+  gap: 8px;
+}
+
+.keyword-cleaning-card {
+  align-items: center;
+}
+
+.keyword-cleaning-card > button {
+  flex: 0 0 auto;
+}
+
+.keyword-cleaning-review {
+  grid-template-columns: repeat(4, minmax(0, 1fr));
+}
+
+.market-normalization-review-queue {
+  display: grid;
+  gap: 8px;
+  min-width: 0;
+  padding: 10px;
+  background: #fff;
+  border: 1px solid var(--line);
+  border-radius: 8px;
+}
+
+.market-normalization-review-queue > div:first-child {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 8px;
+  min-width: 0;
+}
+
+.market-normalization-review-queue > div:first-child span {
+  min-width: 0;
+  color: var(--ink);
+  font-size: 12px;
+  font-weight: 900;
+  overflow-wrap: anywhere;
+}
+
+.market-normalization-review-queue > div:first-child strong {
+  min-width: 28px;
+  color: #2e5a67;
+  text-align: right;
+}
+
+.market-normalization-review-queue > small,
+.market-normalization-review-queue p small {
+  color: var(--muted);
+  font-size: 12px;
+  font-weight: 720;
+  line-height: 1.35;
+}
+
+.market-normalization-review-queue > div:last-child {
+  display: grid;
+  gap: 6px;
+}
+
+.market-normalization-review-queue p {
+  display: grid;
+  gap: 3px;
+  min-width: 0;
+  margin: 0;
+  padding: 8px;
+  background: rgba(24, 32, 29, 0.032);
+  border: 1px solid rgba(24, 32, 29, 0.055);
+  border-radius: 8px;
+}
+
+.market-normalization-review-queue p strong {
+  min-width: 0;
+  color: var(--ink);
+  font-size: 12px;
+  overflow-wrap: anywhere;
+}
+
 .market-wordstat-card {
   align-items: center;
   padding: 10px;
@@ -2174,6 +2820,116 @@ input {
   border-radius: 8px;
 }
 
+.market-decision-board {
+  display: grid;
+  grid-template-columns: minmax(260px, 0.8fr) minmax(0, 1.2fr);
+  gap: 10px;
+  padding: 10px;
+  background: #fff;
+  border: 1px solid var(--line);
+  border-radius: 8px;
+}
+
+.market-decision-verdict {
+  display: grid;
+  align-content: start;
+  gap: 6px;
+  min-width: 0;
+}
+
+.market-decision-verdict > span {
+  justify-self: start;
+  min-height: 24px;
+  display: inline-flex;
+  align-items: center;
+  padding: 0 9px;
+  color: #2e5a67;
+  background: rgba(46, 90, 103, 0.08);
+  border: 1px solid rgba(46, 90, 103, 0.14);
+  border-radius: 999px;
+  font-size: 11px;
+  font-weight: 900;
+}
+
+.market-decision-board.problem .market-decision-verdict > span {
+  color: #8b2f2f;
+  background: rgba(139, 47, 47, 0.07);
+  border-color: rgba(139, 47, 47, 0.12);
+}
+
+.market-decision-board.warning .market-decision-verdict > span {
+  color: #70521f;
+  background: rgba(112, 82, 31, 0.08);
+  border-color: rgba(112, 82, 31, 0.12);
+}
+
+.market-decision-board.good .market-decision-verdict > span {
+  color: #2f6b4f;
+  background: rgba(47, 107, 79, 0.07);
+  border-color: rgba(47, 107, 79, 0.12);
+}
+
+.market-decision-verdict strong {
+  min-width: 0;
+  color: var(--ink);
+  font-size: 16px;
+  line-height: 1.22;
+  overflow-wrap: anywhere;
+}
+
+.market-decision-verdict p {
+  margin: 0;
+  color: var(--muted);
+  font-size: 13px;
+  font-weight: 720;
+  line-height: 1.42;
+  overflow-wrap: anywhere;
+}
+
+.market-decision-metrics {
+  display: grid;
+  grid-template-columns: repeat(5, minmax(0, 1fr));
+  gap: 7px;
+  min-width: 0;
+}
+
+.market-decision-metrics article {
+  display: grid;
+  gap: 4px;
+  min-width: 0;
+  padding: 9px;
+  background: rgba(24, 32, 29, 0.032);
+  border: 1px solid rgba(24, 32, 29, 0.055);
+  border-radius: 12px;
+}
+
+.market-decision-metrics article span,
+.market-decision-metrics article small {
+  min-width: 0;
+  color: var(--muted);
+  font-size: 11px;
+  font-weight: 760;
+  overflow-wrap: anywhere;
+}
+
+.market-decision-metrics article strong {
+  color: var(--ink);
+  font-size: 20px;
+  line-height: 1;
+}
+
+.market-decision-metrics article.tone-good strong {
+  color: #2f6b4f;
+}
+
+.market-decision-metrics article.tone-warning strong {
+  color: #9a681b;
+}
+
+.market-decision-metrics article.tone-problem strong {
+  color: #8b2f2f;
+}
+
 .market-wordstat-card > div:last-of-type {
   display: flex;
   flex-wrap: wrap;
@@ -2272,6 +3028,7 @@ input {
 
 .market-columns section,
 .market-next-actions {
+  align-content: start;
   padding: 10px;
   background: #fafafa;
   border: 1px solid var(--line);
@@ -2308,6 +3065,277 @@ input {
   overflow-wrap: anywhere;
 }
 
+.keyword-plan-board .market-decision-metrics {
+  grid-template-columns: repeat(4, minmax(0, 1fr));
+}
+
+.keyword-plan-board .market-decision-verdict small {
+  margin: 0;
+  color: var(--muted);
+  font-size: 11px;
+  font-weight: 780;
+  line-height: 1.35;
+  overflow-wrap: anywhere;
+}
+
+.keyword-page-plan {
+  display: grid;
+  gap: 10px;
+}
+
+.keyword-page-plan-heading {
+  display: flex;
+  align-items: flex-start;
+  justify-content: space-between;
+  gap: 10px;
+}
+
+.keyword-page-plan-heading > div {
+  display: grid;
+  gap: 4px;
+  min-width: 0;
+}
+
+.keyword-page-plan-heading strong,
+.keyword-page-plan-card strong,
+.keyword-review-queue strong,
+.keyword-next-actions strong {
+  min-width: 0;
+  color: var(--ink);
+  font-size: 13px;
+  overflow-wrap: anywhere;
+}
+
+.keyword-page-plan-heading small,
+.keyword-page-plan-card small,
+.keyword-page-plan-card p,
+.keyword-review-queue small,
+.keyword-next-actions small,
+.keyword-next-action-list p {
+  min-width: 0;
+  margin: 0;
+  color: var(--muted);
+  font-size: 12px;
+  font-weight: 740;
+  line-height: 1.38;
+  overflow-wrap: anywhere;
+}
+
+.keyword-page-plan-heading > span {
+  flex: 0 0 auto;
+  min-height: 24px;
+  display: inline-flex;
+  align-items: center;
+  padding: 0 9px;
+  color: #2e5a67;
+  background: rgba(46, 90, 103, 0.08);
+  border-radius: 999px;
+  font-size: 11px;
+  font-weight: 900;
+  white-space: nowrap;
+}
+
+.keyword-page-plan-grid {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 8px;
+}
+
+.keyword-page-plan-card {
+  display: grid;
+  align-content: start;
+  gap: 9px;
+  min-width: 0;
+  padding: 10px;
+  background: #fff;
+  border: 1px solid var(--line);
+  border-radius: 8px;
+}
+
+.keyword-page-plan-head {
+  display: grid;
+  grid-template-columns: auto minmax(0, 1fr);
+  gap: 8px;
+  align-items: start;
+}
+
+.keyword-page-plan-head > span,
+.keyword-page-plan-stats span,
+.keyword-page-phrase-list span {
+  justify-self: start;
+  min-height: 22px;
+  display: inline-flex;
+  align-items: center;
+  padding: 0 8px;
+  color: var(--muted);
+  background: rgba(24, 32, 29, 0.06);
+  border-radius: 999px;
+  font-size: 11px;
+  font-weight: 900;
+  line-height: 1;
+  white-space: nowrap;
+}
+
+.keyword-page-plan-card.ready .keyword-page-plan-head > span,
+.keyword-page-phrase-list .safe span {
+  color: #2f6b4f;
+  background: rgba(47, 107, 79, 0.08);
+}
+
+.keyword-page-plan-card.review .keyword-page-plan-head > span,
+.keyword-page-phrase-list .review span {
+  color: #70521f;
+  background: rgba(112, 82, 31, 0.09);
+}
+
+.keyword-page-plan-card.blocked .keyword-page-plan-head > span {
+  color: #8b2f2f;
+  background: rgba(139, 47, 47, 0.07);
+}
+
+.keyword-page-plan-head > div {
+  display: grid;
+  gap: 4px;
+  min-width: 0;
+}
+
+.keyword-page-plan-stats {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: flex-start;
+  align-content: flex-start;
+  gap: 6px;
+}
+
+.keyword-page-plan-stats span {
+  flex: 0 0 auto;
+  height: 22px;
+}
+
+.keyword-page-phrase-list {
+  display: grid;
+  gap: 6px;
+}
+
+.keyword-page-phrase-list > div,
+.keyword-raw-grid > div {
+  display: grid;
+  grid-template-columns: auto minmax(0, 1fr);
+  gap: 4px 8px;
+  align-items: start;
+  min-width: 0;
+  padding: 9px;
+  background: rgba(24, 32, 29, 0.032);
+  border: 1px solid rgba(24, 32, 29, 0.055);
+  border-radius: 8px;
+}
+
+.keyword-page-phrase-list strong,
+.keyword-page-phrase-list small,
+.keyword-raw-grid strong,
+.keyword-raw-grid small {
+  min-width: 0;
+  overflow-wrap: anywhere;
+}
+
+.keyword-page-phrase-list small,
+.keyword-raw-grid small {
+  grid-column: 2;
+}
+
+.keyword-plan-support-grid {
+  align-items: start;
+}
+
+.keyword-review-queue,
+.keyword-next-actions {
+  min-width: 0;
+}
+
+.keyword-next-action-list {
+  display: grid;
+  gap: 7px;
+}
+
+.keyword-next-action-list p {
+  padding: 9px;
+  background: rgba(24, 32, 29, 0.032);
+  border: 1px solid rgba(24, 32, 29, 0.055);
+  border-radius: 8px;
+}
+
+.keyword-raw-details {
+  margin-top: 0;
+}
+
+.keyword-raw-grid {
+  display: grid;
+  gap: 6px;
+}
+
+.keyword-raw-grid span {
+  justify-self: start;
+  min-height: 22px;
+  display: inline-flex;
+  align-items: center;
+  padding: 0 8px;
+  color: var(--muted);
+  background: rgba(24, 32, 29, 0.06);
+  border-radius: 999px;
+  font-size: 11px;
+  font-weight: 900;
+  line-height: 1;
+  white-space: nowrap;
+}
+
+.materialization-target-list {
+  display: grid;
+  gap: 8px;
+}
+
+.materialization-target {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) auto;
+  gap: 10px;
+  align-items: start;
+  padding: 9px;
+  background: #fff;
+  border: 1px solid var(--line);
+  border-radius: 7px;
+}
+
+.materialization-target > div:first-child {
+  display: grid;
+  gap: 4px;
+  min-width: 0;
+}
+
+.materialization-target span {
+  width: fit-content;
+  padding: 2px 7px;
+  color: var(--muted);
+  font-size: 10px;
+  font-weight: 900;
+  text-transform: uppercase;
+  background: #f5f5f5;
+  border: 1px solid var(--line);
+  border-radius: 999px;
+}
+
+.materialization-target strong,
+.materialization-target small {
+  min-width: 0;
+  overflow-wrap: anywhere;
+}
+
+.materialization-target-actions {
+  display: flex;
+  flex-wrap: wrap;
+  justify-content: flex-end;
+  gap: 6px;
+  max-width: 360px;
+}
+
 .market-wordstat-results > div {
   display: grid;
   gap: 5px;
@@ -2325,6 +3353,852 @@ input {
   font-weight: 900;
 }
 
+.seo-chart-grid {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 8px;
+  min-width: 0;
+}
+
+.seo-chart-grid-wide {
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+}
+
+.seo-chart-grid-market {
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+}
+
+.seo-chart-grid-keyword-cleaning {
+  grid-template-columns: minmax(0, 0.9fr) minmax(0, 1.1fr);
+}
+
+.seo-chart {
+  display: grid;
+  gap: 10px;
+  min-width: 0;
+  padding: 10px;
+  background: rgba(255, 255, 255, 0.86);
+  border: 1px solid var(--line);
+  border-radius: 8px;
+}
+
+.seo-bklit-chart {
+  --background: #fff;
+  --foreground: #202124;
+  --muted-foreground: #686d70;
+  --border: rgba(24, 32, 29, 0.12);
+  --color-muted: rgba(24, 32, 29, 0.045);
+  --chart-background: rgba(255, 255, 255, 0);
+  --chart-foreground: #202124;
+  --chart-foreground-muted: #68757a;
+  --chart-label: #697174;
+  --chart-grid: rgba(24, 32, 29, 0.14);
+  --chart-1: #2f6b4f;
+  --chart-2: #b9821f;
+  --chart-3: #536879;
+  --chart-4: #8b2f2f;
+  --chart-5: #6f5d8f;
+  --chart-line-primary: #2f6b4f;
+  --chart-line-secondary: #536879;
+  --color-red-500: #8b2f2f;
+  --color-emerald-500: #2f6b4f;
+}
+
+.seo-bklit-native {
+  min-width: 0;
+  color: var(--foreground);
+}
+
+.seo-bklit-native svg {
+  max-width: 100%;
+}
+
+.seo-bklit-native .relative,
+.seo-bklit-chart .relative {
+  position: relative;
+}
+
+.seo-bklit-native .absolute,
+.seo-bklit-chart .absolute {
+  position: absolute;
+}
+
+.seo-bklit-native .inset-0,
+.seo-bklit-chart .inset-0 {
+  inset: 0;
+}
+
+.seo-bklit-native .flex,
+.seo-bklit-chart .flex {
+  display: flex;
+}
+
+.seo-bklit-native .grid,
+.seo-bklit-chart .grid {
+  display: grid;
+}
+
+.seo-bklit-native .flex-row,
+.seo-bklit-chart .flex-row {
+  flex-direction: row;
+}
+
+.seo-bklit-native .flex-col,
+.seo-bklit-chart .flex-col {
+  flex-direction: column;
+}
+
+.seo-bklit-native .flex-1,
+.seo-bklit-chart .flex-1 {
+  flex: 1 1 0%;
+}
+
+.seo-bklit-native .shrink-0,
+.seo-bklit-chart .shrink-0 {
+  flex-shrink: 0;
+}
+
+.seo-bklit-native .items-center,
+.seo-bklit-chart .items-center {
+  align-items: center;
+}
+
+.seo-bklit-native .items-start,
+.seo-bklit-chart .items-start {
+  align-items: flex-start;
+}
+
+.seo-bklit-native .items-end,
+.seo-bklit-chart .items-end {
+  align-items: flex-end;
+}
+
+.seo-bklit-native .justify-center,
+.seo-bklit-chart .justify-center {
+  justify-content: center;
+}
+
+.seo-bklit-native .justify-start,
+.seo-bklit-chart .justify-start {
+  justify-content: flex-start;
+}
+
+.seo-bklit-native .justify-end,
+.seo-bklit-chart .justify-end {
+  justify-content: flex-end;
+}
+
+.seo-bklit-native .w-full,
+.seo-bklit-chart .w-full {
+  width: 100%;
+}
+
+.seo-bklit-native .h-full,
+.seo-bklit-chart .h-full {
+  height: 100%;
+}
+
+.seo-bklit-native .size-full,
+.seo-bklit-chart .size-full {
+  width: 100%;
+  height: 100%;
+}
+
+.seo-bklit-native .min-w-0,
+.seo-bklit-chart .min-w-0 {
+  min-width: 0;
+}
+
+.seo-bklit-native .min-h-0,
+.seo-bklit-chart .min-h-0 {
+  min-height: 0;
+}
+
+.seo-bklit-native .overflow-visible,
+.seo-bklit-chart .overflow-visible {
+  overflow: visible;
+}
+
+.seo-bklit-native .overflow-hidden,
+.seo-bklit-chart .overflow-hidden {
+  overflow: hidden;
+}
+
+.seo-bklit-native .pointer-events-none,
+.seo-bklit-chart .pointer-events-none {
+  pointer-events: none;
+}
+
+.seo-bklit-native .cursor-pointer,
+.seo-bklit-chart .cursor-pointer {
+  cursor: pointer;
+}
+
+.seo-bklit-native .select-none,
+.seo-bklit-chart .select-none {
+  user-select: none;
+}
+
+.seo-bklit-native .whitespace-nowrap,
+.seo-bklit-chart .whitespace-nowrap {
+  white-space: nowrap;
+}
+
+.seo-bklit-native .text-center,
+.seo-bklit-chart .text-center {
+  text-align: center;
+}
+
+.seo-bklit-native .font-bold,
+.seo-bklit-chart .font-bold {
+  font-weight: 900;
+}
+
+.seo-bklit-native .font-semibold,
+.seo-bklit-chart .font-semibold {
+  font-weight: 820;
+}
+
+.seo-bklit-native .font-medium,
+.seo-bklit-chart .font-medium {
+  font-weight: 720;
+}
+
+.seo-bklit-native .tabular-nums,
+.seo-bklit-chart .tabular-nums {
+  font-variant-numeric: tabular-nums;
+}
+
+.seo-bklit-native .leading-none,
+.seo-bklit-chart .leading-none {
+  line-height: 1;
+}
+
+.seo-bklit-native .leading-tight,
+.seo-bklit-chart .leading-tight {
+  line-height: 1.15;
+}
+
+.seo-bklit-native .truncate,
+.seo-bklit-chart .truncate {
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.seo-bklit-native .text-foreground,
+.seo-bklit-chart .text-foreground {
+  color: var(--foreground);
+}
+
+.seo-bklit-native .text-background,
+.seo-bklit-chart .text-background {
+  color: var(--background);
+}
+
+.seo-bklit-native .text-muted-foreground,
+.seo-bklit-chart .text-muted-foreground,
+.seo-bklit-native .text-chart-label,
+.seo-bklit-chart .text-chart-label {
+  color: var(--chart-label);
+}
+
+.seo-bklit-native .bg-foreground,
+.seo-bklit-chart .bg-foreground {
+  background: var(--foreground);
+}
+
+.seo-bklit-native .rounded-full,
+.seo-bklit-chart .rounded-full {
+  border-radius: 999px;
+}
+
+.seo-bklit-native .shadow-sm,
+.seo-bklit-chart .shadow-sm {
+  box-shadow: 0 4px 10px rgba(24, 32, 29, 0.1);
+}
+
+.seo-bklit-native .text-xs,
+.seo-bklit-chart .text-xs {
+  font-size: 10px;
+  line-height: 1.2;
+}
+
+.seo-bklit-native .text-sm,
+.seo-bklit-chart .text-sm {
+  font-size: 11px;
+  line-height: 1.2;
+}
+
+.seo-bklit-native .text-2xl,
+.seo-bklit-chart .text-2xl {
+  font-size: 20px;
+  line-height: 1;
+}
+
+.seo-bklit-native .px-3,
+.seo-bklit-chart .px-3 {
+  padding-right: 10px;
+  padding-left: 10px;
+}
+
+.seo-bklit-native .py-1,
+.seo-bklit-chart .py-1 {
+  padding-top: 3px;
+  padding-bottom: 3px;
+}
+
+.seo-bklit-native .pb-1,
+.seo-bklit-chart .pb-1 {
+  padding-bottom: 4px;
+}
+
+.seo-bklit-native .pt-1,
+.seo-bklit-chart .pt-1 {
+  padding-top: 4px;
+}
+
+.seo-bklit-native .pr-2,
+.seo-bklit-chart .pr-2 {
+  padding-right: 8px;
+}
+
+.seo-bklit-native .pl-2,
+.seo-bklit-chart .pl-2 {
+  padding-left: 8px;
+}
+
+.seo-bklit-native .mt-0\.5,
+.seo-bklit-chart .mt-0\.5 {
+  margin-top: 2px;
+}
+
+.seo-bklit-native .mb-2,
+.seo-bklit-chart .mb-2 {
+  margin-bottom: 8px;
+}
+
+.seo-bklit-native .h-\[16\%\],
+.seo-bklit-chart .h-\[16\%\] {
+  height: 16%;
+}
+
+.seo-bklit-native .w-\[16\%\],
+.seo-bklit-chart .w-\[16\%\] {
+  width: 16%;
+}
+
+.seo-bklit-funnel-native {
+  min-height: 158px;
+  padding-top: 8px;
+  padding-right: 22px;
+  padding-left: 22px;
+}
+
+.seo-bklit-funnel-native > div {
+  min-height: 158px;
+}
+
+.seo-bklit-ring-native {
+  display: flex;
+  justify-content: center;
+}
+
+.seo-bklit-radar-native {
+  display: flex;
+  justify-content: center;
+  min-height: 190px;
+}
+
+.seo-bklit-scatter-native {
+  background: rgba(250, 250, 250, 0.78);
+}
+
+.seo-chart-heading {
+  display: grid;
+  gap: 3px;
+  min-width: 0;
+}
+
+.seo-chart-heading strong {
+  min-width: 0;
+  color: var(--ink);
+  font-size: 13px;
+  line-height: 1.2;
+  overflow-wrap: anywhere;
+}
+
+.seo-chart-heading small,
+.seo-chart-empty {
+  margin: 0;
+  color: var(--muted);
+  font-size: 12px;
+  font-weight: 720;
+  line-height: 1.35;
+}
+
+.seo-funnel-rows,
+.seo-bar-rows {
+  display: grid;
+  gap: 7px;
+  min-width: 0;
+}
+
+.seo-funnel-row,
+.seo-bar-row {
+  display: grid;
+  grid-template-columns: minmax(106px, 0.52fr) minmax(0, 1fr);
+  gap: 4px 8px;
+  align-items: center;
+  min-width: 0;
+}
+
+.seo-funnel-row > div:first-child,
+.seo-bar-row > div:first-child {
+  display: flex;
+  align-items: baseline;
+  justify-content: space-between;
+  gap: 8px;
+  min-width: 0;
+}
+
+.seo-funnel-row span,
+.seo-bar-row span {
+  min-width: 0;
+  color: #343434;
+  font-size: 11px;
+  font-weight: 840;
+  line-height: 1.2;
+  overflow-wrap: anywhere;
+}
+
+.seo-funnel-row strong,
+.seo-bar-row strong {
+  color: var(--ink);
+  font-size: 12px;
+  font-weight: 920;
+  line-height: 1.1;
+  white-space: nowrap;
+}
+
+.seo-funnel-row small,
+.seo-bar-row small {
+  grid-column: 1 / -1;
+  color: var(--muted);
+  font-size: 11px;
+  font-weight: 700;
+  line-height: 1.25;
+  overflow-wrap: anywhere;
+}
+
+.seo-funnel-track,
+.seo-bar-track {
+  position: relative;
+  height: 10px;
+  overflow: hidden;
+  background: rgba(24, 32, 29, 0.06);
+  border: 1px solid rgba(24, 32, 29, 0.06);
+  border-radius: 999px;
+}
+
+.seo-funnel-track span,
+.seo-bar-track span {
+  display: block;
+  height: 100%;
+  min-width: 0;
+  background: #7a8080;
+  border-radius: inherit;
+}
+
+.seo-funnel-track span {
+  width: var(--seo-funnel-width);
+}
+
+.seo-bar-track span {
+  width: var(--seo-bar-width);
+}
+
+.seo-funnel-row.tone-good .seo-funnel-track span,
+.seo-bar-row.tone-good .seo-bar-track span,
+.seo-scatter-chart circle.tone-good,
+.seo-scatter-legend .tone-good {
+  background: #2f6b4f;
+  fill: #2f6b4f;
+}
+
+.seo-funnel-row.tone-warning .seo-funnel-track span,
+.seo-bar-row.tone-warning .seo-bar-track span,
+.seo-scatter-chart circle.tone-warning,
+.seo-scatter-legend .tone-warning {
+  background: #b2771f;
+  fill: #b2771f;
+}
+
+.seo-funnel-row.tone-problem .seo-funnel-track span,
+.seo-bar-row.tone-problem .seo-bar-track span,
+.seo-scatter-chart circle.tone-problem,
+.seo-scatter-legend .tone-problem {
+  background: #8b2f2f;
+  fill: #8b2f2f;
+}
+
+.seo-funnel-row.tone-neutral .seo-funnel-track span,
+.seo-bar-row.tone-neutral .seo-bar-track span,
+.seo-scatter-chart circle.tone-neutral,
+.seo-scatter-legend .tone-neutral {
+  background: #536879;
+  fill: #536879;
+}
+
+.seo-shape-funnel-body,
+.seo-ring-body,
+.seo-radar-body {
+  display: grid;
+  grid-template-columns: minmax(150px, 0.95fr) minmax(0, 1fr);
+  gap: 10px;
+  align-items: center;
+  min-width: 0;
+}
+
+.seo-shape-funnel-svg,
+.seo-ring-svg,
+.seo-radar-svg {
+  display: block;
+  width: 100%;
+  min-width: 0;
+}
+
+.seo-shape-funnel-svg {
+  min-height: 166px;
+  filter: drop-shadow(0 14px 20px rgba(24, 32, 29, 0.08));
+}
+
+.seo-shape-funnel-band {
+  fill: var(--seo-chart-fill);
+  opacity: 0.9;
+  stroke: rgba(255, 255, 255, 0.82);
+  stroke-width: 2;
+}
+
+.seo-chart-legend,
+.seo-radar-legend {
+  display: grid;
+  gap: 7px;
+  min-width: 0;
+}
+
+.seo-chart-legend div,
+.seo-radar-legend div {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) auto;
+  gap: 2px 8px;
+  align-items: baseline;
+  min-width: 0;
+  padding-bottom: 6px;
+  border-bottom: 1px solid rgba(24, 32, 29, 0.07);
+}
+
+.seo-chart-legend div:last-child,
+.seo-radar-legend div:last-child {
+  padding-bottom: 0;
+  border-bottom: 0;
+}
+
+.seo-chart-legend span,
+.seo-radar-legend span {
+  display: inline-flex;
+  align-items: center;
+  min-width: 0;
+  color: #343434;
+  font-size: 11px;
+  font-weight: 860;
+  line-height: 1.2;
+  overflow-wrap: anywhere;
+}
+
+.seo-chart-legend i {
+  width: 8px;
+  height: 8px;
+  flex: 0 0 auto;
+  margin-right: 6px;
+  background: var(--seo-chart-fill);
+  border-radius: 999px;
+}
+
+.seo-chart-legend strong,
+.seo-radar-legend strong {
+  color: var(--ink);
+  font-size: 12px;
+  font-weight: 920;
+  line-height: 1.1;
+  white-space: nowrap;
+}
+
+.seo-chart-legend small,
+.seo-radar-legend small {
+  grid-column: 1 / -1;
+  color: var(--muted);
+  font-size: 10.5px;
+  font-weight: 700;
+  line-height: 1.25;
+  overflow-wrap: anywhere;
+}
+
+.seo-ring-svg {
+  max-width: 168px;
+  justify-self: center;
+}
+
+.seo-ring-base {
+  fill: none;
+  stroke: rgba(24, 32, 29, 0.08);
+  stroke-width: 15;
+}
+
+.seo-ring-segment {
+  fill: none;
+  stroke: var(--seo-chart-fill);
+  stroke-linecap: round;
+  stroke-width: 15;
+}
+
+.seo-ring-value {
+  fill: var(--ink);
+  font-size: 19px;
+  font-weight: 930;
+}
+
+.seo-ring-label {
+  fill: var(--muted);
+  font-size: 9px;
+  font-weight: 860;
+  text-transform: uppercase;
+}
+
+.seo-radar-svg {
+  min-height: 180px;
+  overflow: visible;
+}
+
+.seo-radar-ring {
+  fill: none;
+  stroke: rgba(24, 32, 29, 0.1);
+  stroke-width: 0.8;
+}
+
+.seo-radar-axis {
+  stroke: rgba(24, 32, 29, 0.14);
+  stroke-width: 0.8;
+}
+
+.seo-radar-area {
+  fill: rgba(47, 107, 79, 0.18);
+  stroke: #2f6b4f;
+  stroke-linejoin: round;
+  stroke-width: 2.2;
+}
+
+.seo-radar-dot {
+  fill: var(--seo-chart-fill);
+  stroke: #fff;
+  stroke-width: 1.4;
+}
+
+.seo-heatmap-table {
+  display: grid;
+  gap: 6px;
+  min-width: 0;
+  overflow-x: auto;
+  padding-bottom: 2px;
+}
+
+.seo-heatmap-header,
+.seo-heatmap-row {
+  display: grid;
+  gap: 6px;
+  min-width: 360px;
+  align-items: center;
+}
+
+.seo-heatmap-header span {
+  color: var(--muted);
+  font-size: 10px;
+  font-weight: 880;
+  line-height: 1.1;
+  text-transform: uppercase;
+}
+
+.seo-heatmap-row strong {
+  min-width: 0;
+  color: var(--ink);
+  font-size: 11px;
+  font-weight: 900;
+  line-height: 1.15;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.seo-heatmap-row span {
+  min-height: 30px;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  color: rgba(24, 32, 29, 0.52);
+  background: rgba(24, 32, 29, 0.05);
+  border: 1px solid rgba(24, 32, 29, 0.07);
+  border-radius: 8px;
+  font-size: 11px;
+  font-weight: 900;
+  line-height: 1;
+}
+
+.seo-heatmap-row span.active {
+  color: #193126;
+  background: rgba(47, 107, 79, var(--seo-cell-alpha));
+  border-color: rgba(47, 107, 79, 0.14);
+}
+
+.seo-heatmap-native-layout {
+  display: grid;
+  gap: 7px;
+  min-width: 0;
+}
+
+.seo-heatmap-native-columns {
+  display: grid;
+  grid-template-columns: 96px repeat(4, minmax(42px, 1fr));
+  gap: 6px;
+  min-width: 0;
+}
+
+.seo-heatmap-native-columns span {
+  min-width: 0;
+  color: var(--muted);
+  font-size: 10px;
+  font-weight: 880;
+  line-height: 1.1;
+  text-align: center;
+  text-transform: uppercase;
+}
+
+.seo-heatmap-native-main {
+  display: grid;
+  grid-template-columns: 96px minmax(0, 1fr);
+  gap: 6px;
+  min-width: 0;
+}
+
+.seo-heatmap-native-rows {
+  display: grid;
+  gap: 6px;
+  min-width: 0;
+}
+
+.seo-heatmap-native-rows strong {
+  min-height: 30px;
+  display: flex;
+  align-items: center;
+  min-width: 0;
+  color: var(--ink);
+  font-size: 11px;
+  font-weight: 900;
+  line-height: 1.15;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.seo-bklit-heatmap-native {
+  min-width: 0;
+}
+
+.seo-bklit-heatmap-chart {
+  min-height: 138px;
+}
+
+.seo-bklit-heatmap-chart svg {
+  display: block;
+}
+
+.seo-scatter-frame {
+  position: relative;
+  min-height: 176px;
+  padding: 10px 8px 24px 26px;
+  background: rgba(250, 250, 250, 0.78);
+  border: 1px solid var(--line);
+  border-radius: 8px;
+}
+
+.seo-scatter-frame svg {
+  display: block;
+  width: 100%;
+  height: 136px;
+  overflow: visible;
+}
+
+.seo-scatter-axis {
+  stroke: rgba(24, 32, 29, 0.34);
+  stroke-width: 0.7;
+}
+
+.seo-scatter-guide {
+  stroke: rgba(24, 32, 29, 0.13);
+  stroke-dasharray: 3 3;
+  stroke-width: 0.6;
+}
+
+.seo-scatter-chart circle {
+  opacity: 0.84;
+  stroke: #fff;
+  stroke-width: 1.2;
+}
+
+.seo-scatter-frame > span,
+.seo-scatter-frame > small {
+  position: absolute;
+  color: var(--muted);
+  font-size: 10px;
+  font-weight: 850;
+  line-height: 1;
+  text-transform: uppercase;
+}
+
+.seo-scatter-frame > span {
+  top: 12px;
+  left: 8px;
+  writing-mode: vertical-rl;
+  transform: rotate(180deg);
+}
+
+.seo-scatter-frame > small {
+  right: 10px;
+  bottom: 8px;
+}
+
+.seo-scatter-legend {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 5px;
+  min-width: 0;
+}
+
+.seo-scatter-legend span {
+  display: inline-flex;
+  max-width: 100%;
+  min-height: 22px;
+  align-items: center;
+  padding: 0 7px;
+  color: #fff;
+  border-radius: 999px;
+  font-size: 10px;
+  font-weight: 850;
+  line-height: 1.1;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
 .semantic-term-cloud {
   display: flex;
   flex-wrap: wrap;
@@ -4391,10 +6265,16 @@ input[type="checkbox"] {
   }
 
   .semantic-score-grid,
+  .semantic-review-summary,
+  .semantic-review-next,
   .semantic-scope-grid {
     grid-template-columns: 1fr;
   }
 
+  .semantic-review-card.semantic-context-card {
+    grid-column: auto;
+  }
+
   .semantic-verdict-heading,
   .semantic-detail-heading {
     display: grid;
@@ -5643,6 +7523,255 @@ input[type="checkbox"] {
     linear-gradient(145deg, #1d1d1f, #2b2b2e) !important;
 }
 
+.nav-item.locked {
+  cursor: not-allowed !important;
+  opacity: 0.42;
+}
+
+.nav-item.locked:hover {
+  color: var(--muted) !important;
+  background: transparent !important;
+}
+
+.flow-status-strip {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 14px;
+  padding: 12px 16px;
+  background: rgba(255, 255, 255, 0.72);
+  border: 1px solid var(--line);
+  border-radius: 8px;
+  box-shadow: var(--shadow-sm);
+}
+
+.flow-status-strip > div:first-child {
+  display: grid;
+  min-width: 0;
+  gap: 4px;
+}
+
+.flow-status-strip span {
+  color: #4e6976;
+  font-size: 11px;
+  font-weight: 900;
+  text-transform: uppercase;
+}
+
+.flow-status-strip strong {
+  color: var(--ink);
+  overflow-wrap: anywhere;
+}
+
+.flow-status-strip small {
+  color: var(--muted);
+  font-weight: 760;
+  line-height: 1.35;
+}
+
+.flow-status-strip.locked {
+  background: rgba(250, 250, 250, 0.72);
+}
+
+.flow-status-strip.locked span {
+  color: #8b2f2f;
+}
+
+.flow-status-metrics {
+  display: flex;
+  flex-wrap: wrap;
+  justify-content: flex-end;
+  gap: 6px;
+}
+
+.flow-status-metrics span {
+  padding: 5px 8px;
+  color: #2f6b4f;
+  background: rgba(47, 107, 79, 0.07);
+  border: 1px solid rgba(47, 107, 79, 0.12);
+  border-radius: 999px;
+  text-transform: none;
+}
+
+.project-flow-actions {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+  margin-top: 8px;
+}
+
+.configuration-confirm-bar {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 16px;
+  padding: 12px;
+  background: #f8faf8;
+  border: 1px solid var(--line);
+  border-radius: 8px;
+}
+
+.configuration-confirm-bar > div {
+  display: grid;
+  min-width: 0;
+  gap: 4px;
+}
+
+.configuration-confirm-bar span,
+.strategy-phase-heading span,
+.strategy-phase-detail span,
+.strategy-phase-detail-grid span {
+  color: #4e6976;
+  font-size: 11px;
+  font-weight: 900;
+  text-transform: uppercase;
+}
+
+.configuration-confirm-bar strong,
+.strategy-phase-heading strong,
+.strategy-phase-detail strong {
+  color: var(--ink);
+}
+
+.configuration-confirm-bar small {
+  color: var(--muted);
+  font-weight: 760;
+}
+
+.strategy-phase-selector {
+  display: grid;
+  gap: 10px;
+  padding: 12px;
+  background: #fff;
+  border: 1px solid var(--line);
+  border-radius: 8px;
+}
+
+.strategy-phase-heading {
+  display: flex;
+  align-items: flex-start;
+  justify-content: space-between;
+  gap: 12px;
+}
+
+.strategy-phase-heading > div {
+  display: grid;
+  gap: 4px;
+}
+
+.strategy-phase-heading small,
+.strategy-phase-detail p {
+  margin: 0;
+  color: var(--muted);
+  font-size: 12px;
+  font-weight: 760;
+  line-height: 1.4;
+}
+
+.strategy-phase-tabs {
+  display: grid;
+  grid-template-columns: repeat(4, minmax(0, 1fr));
+  gap: 8px;
+}
+
+.strategy-phase-tabs button {
+  display: grid;
+  min-height: 112px;
+  gap: 6px;
+  align-content: start;
+  padding: 10px;
+  text-align: left;
+  background: #fafafa;
+  border: 1px solid var(--line);
+  border-radius: 8px;
+  cursor: pointer;
+}
+
+.strategy-phase-tabs button.active {
+  background: rgba(47, 107, 79, 0.08);
+  border-color: rgba(47, 107, 79, 0.28);
+}
+
+.strategy-phase-tabs button.recommended {
+  box-shadow: inset 0 0 0 1px rgba(47, 107, 79, 0.22);
+}
+
+.strategy-phase-tabs button span {
+  justify-self: start;
+  padding: 4px 8px;
+  color: #2f6b4f;
+  background: rgba(47, 107, 79, 0.07);
+  border-radius: 999px;
+  font-size: 11px;
+  font-weight: 900;
+}
+
+.strategy-phase-tabs button strong {
+  color: var(--ink);
+  font-size: 14px;
+  line-height: 1.2;
+}
+
+.strategy-phase-tabs button small {
+  color: var(--muted);
+  font-size: 12px;
+  font-weight: 760;
+  line-height: 1.35;
+}
+
+.strategy-phase-detail {
+  display: grid;
+  gap: 10px;
+  padding: 12px;
+  background: #f8faf8;
+  border: 1px solid rgba(47, 107, 79, 0.14);
+  border-radius: 8px;
+}
+
+.strategy-phase-detail > div:first-child {
+  display: grid;
+  gap: 4px;
+}
+
+.strategy-phase-detail-grid {
+  display: grid;
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+  gap: 8px;
+}
+
+.strategy-phase-detail-grid article {
+  display: grid;
+  align-content: start;
+  gap: 6px;
+  padding: 10px;
+  background: rgba(255, 255, 255, 0.72);
+  border: 1px solid var(--line);
+  border-radius: 8px;
+}
+
+.strategy-phase-detail-grid article strong {
+  color: var(--ink);
+  font-size: 12px;
+  line-height: 1.35;
+}
+
+@media (max-width: 900px) {
+  .flow-status-strip,
+  .configuration-confirm-bar {
+    align-items: stretch;
+    flex-direction: column;
+  }
+
+  .flow-status-metrics {
+    justify-content: flex-start;
+  }
+
+  .strategy-phase-tabs,
+  .strategy-phase-detail-grid {
+    grid-template-columns: 1fr;
+  }
+}
+
 .topbar {
   color: #fff !important;
   background:
@@ -6299,7 +8428,10 @@ input[type="checkbox"] {
   .auto-mode-flow,
   .auto-variant-board,
   .market-provider-grid,
-  .market-columns {
+  .market-columns,
+  .seo-chart-grid,
+  .seo-chart-grid-market,
+  .seo-chart-grid-wide {
     grid-template-columns: 1fr;
   }
 
@@ -7362,14 +9494,18 @@ input[type="checkbox"] {
 .stage-2 .project-form,
 .stage-3 .project-form,
 .stage-4 .project-form,
-.stage-5 .project-form {
+.stage-5 .project-form,
+.stage-6 .project-form,
+.stage-7 .project-form {
   display: none !important;
 }
 
 .stage-2 .project-grid,
 .stage-3 .project-grid,
 .stage-4 .project-grid,
-.stage-5 .project-grid {
+.stage-5 .project-grid,
+.stage-6 .project-grid,
+.stage-7 .project-grid {
   grid-template-columns: minmax(0, 1fr) !important;
 }
 
@@ -7380,7 +9516,9 @@ input[type="checkbox"] {
 
 .stage-3 .project-scan-status,
 .stage-4 .project-scan-status,
-.stage-5 .project-scan-status {
+.stage-5 .project-scan-status,
+.stage-6 .project-scan-status,
+.stage-7 .project-scan-status {
   display: none !important;
 }
 
@@ -7427,7 +9565,21 @@ input[type="checkbox"] {
 .stage-5 .audit-toolbar,
 .stage-5 .audit-help,
 .stage-5 .media-issue-panel,
-.stage-5 .audit-issue-list {
+.stage-5 .audit-issue-list,
+.stage-6 .scan-selection,
+.stage-6 .page-workspace-panel,
+.stage-6 .audit-summary,
+.stage-6 .audit-toolbar,
+.stage-6 .audit-help,
+.stage-6 .media-issue-panel,
+.stage-6 .audit-issue-list,
+.stage-7 .scan-selection,
+.stage-7 .page-workspace-panel,
+.stage-7 .audit-summary,
+.stage-7 .audit-toolbar,
+.stage-7 .audit-help,
+.stage-7 .media-issue-panel,
+.stage-7 .audit-issue-list {
   display: none !important;
 }
 
@@ -7450,15 +9602,11 @@ input[type="checkbox"] {
   box-shadow: 0 0 0 4px rgba(255, 79, 184, 0.18) !important;
 }
 
-.stage-6 .project-setup,
-.stage-7 .project-setup,
 .stage-8 .project-setup,
 .stage-9 .project-setup {
   display: none !important;
 }
 
-.stage-6 .stage-placeholder,
-.stage-7 .stage-placeholder,
 .stage-8 .stage-placeholder,
 .stage-9 .stage-placeholder {
   display: grid;
@@ -7471,7 +9619,10 @@ input[type="checkbox"] {
 
   .stage-2 .project-grid,
   .stage-3 .project-grid,
-  .stage-4 .project-grid {
+  .stage-4 .project-grid,
+  .stage-5 .project-grid,
+  .stage-6 .project-grid,
+  .stage-7 .project-grid {
     grid-template-columns: minmax(0, 1fr) !important;
   }
 }
@@ -7558,10 +9709,14 @@ input[type="checkbox"] {
 .market-panel,
 .market-heading,
 .market-state-card,
-.market-wordstat-card,
-.market-provider,
-.market-columns section,
-.market-next-actions {
+.market-decision-board,
+  .market-wordstat-card,
+  .market-provider,
+  .market-normalization-card,
+  .market-normalization-review-queue,
+  .keyword-page-plan-card,
+  .market-columns section,
+  .market-next-actions {
   background: var(--nodedc-glass-panel-surface-strong) !important;
   border: 0 !important;
   border-radius: 22px !important;
@@ -7588,10 +9743,14 @@ input[type="checkbox"] {
 .market-panel,
 .market-heading,
 .market-state-card,
-.market-wordstat-card,
-.market-provider,
-.market-columns section,
-.market-next-actions {
+.market-decision-board,
+  .market-wordstat-card,
+  .market-provider,
+  .market-normalization-card,
+  .market-normalization-review-queue,
+  .keyword-page-plan-card,
+  .market-columns section,
+  .market-next-actions {
   overflow: hidden !important;
 }
 
@@ -7610,10 +9769,14 @@ input[type="checkbox"] {
 .market-panel,
 .market-heading,
 .market-state-card,
-.market-wordstat-card,
-.market-provider,
-.market-columns section,
-.market-next-actions {
+.market-decision-board,
+  .market-wordstat-card,
+  .market-provider,
+  .market-normalization-card,
+  .market-normalization-review-queue,
+  .keyword-page-plan-card,
+  .market-columns section,
+  .market-next-actions {
   position: relative;
 }
 
@@ -7634,10 +9797,14 @@ input[type="checkbox"] {
 .market-panel::after,
 .market-heading::after,
 .market-state-card::after,
-.market-wordstat-card::after,
-.market-provider::after,
-.market-columns section::after,
-.market-next-actions::after {
+.market-decision-board::after,
+  .market-wordstat-card::after,
+  .market-provider::after,
+  .market-normalization-card::after,
+  .market-normalization-review-queue::after,
+  .keyword-page-plan-card::after,
+  .market-columns section::after,
+  .market-next-actions::after {
   content: "";
   position: absolute;
   inset: 0;
@@ -7680,10 +9847,13 @@ input[type="checkbox"] {
 .semantic-brief-section,
 .semantic-brief-quality-card,
 .semantic-landing-row,
-.market-wordstat-card > div:last-of-type,
-.market-seed-list div,
-.market-brief-list div,
-.market-wordstat-results > div,
+  .market-wordstat-card > div:last-of-type,
+  .market-seed-list div,
+  .market-brief-list div,
+  .keyword-page-phrase-list > div,
+  .keyword-next-action-list p,
+  .keyword-raw-grid > div,
+  .market-wordstat-results > div,
 .semantic-cluster,
 .semantic-detail-grid section,
 .semantic-evidence-panel,
@@ -7761,9 +9931,14 @@ input[type="checkbox"] {
 .market-wordstat-card > div:last-of-type span,
 .market-state-card > div > span,
 .market-provider > span,
-.market-seed-list span,
-.market-brief-list span,
-.market-wordstat-results p span,
+  .market-seed-list span,
+  .market-brief-list span,
+  .keyword-page-plan-heading > span,
+  .keyword-page-plan-head > span,
+  .keyword-page-plan-stats span,
+  .keyword-page-phrase-list span,
+  .keyword-raw-grid span,
+  .market-wordstat-results p span,
 .semantic-term-cloud span {
   color: var(--muted) !important;
   background: rgba(24, 32, 29, 0.06) !important;
@@ -7903,13 +10078,18 @@ textarea:focus {
 .market-state-card.not_collected > div > span,
 .market-state-card.partial_ready > div > span,
 .market-provider.connected > span,
-.market-seed-list span.collected,
-.market-seed-list span.collected_related_only,
-.market-brief-list span.collected,
-.market-seed-list span.ready_for_collection,
-.market-brief-list span.ready_for_collection,
-.market-seed-list span.collected_no_signal,
-.market-state-card.not_configured > div > span,
+  .market-seed-list span.collected,
+  .market-seed-list span.collected_related_only,
+  .market-brief-list span.collected,
+  .market-seed-list span.ready_for_collection,
+  .market-brief-list span.ready_for_collection,
+  .market-seed-list span.collected_no_signal,
+  .keyword-page-plan-card.ready .keyword-page-plan-head > span,
+  .keyword-page-plan-card.review .keyword-page-plan-head > span,
+  .keyword-page-plan-card.blocked .keyword-page-plan-head > span,
+  .keyword-page-phrase-list .safe span,
+  .keyword-page-phrase-list .review span,
+  .market-state-card.not_configured > div > span,
 .market-provider.not_configured > span,
 .market-provider.not_implemented > span,
 .market-seed-list span.collection_failed,
@@ -8060,3 +10240,2112 @@ textarea:focus {
   font-weight: 520;
   line-height: 1.35;
 }
+
+/* SEO module polish pass: softer controls, no clipped analytical panels. */
+.workspace-mode-switch {
+  padding: 4px !important;
+  border-radius: 999px !important;
+}
+
+.workspace-mode-switch button {
+  min-height: 36px !important;
+  padding: 0 16px !important;
+  border-radius: 999px !important;
+}
+
+.topbar,
+.stage-decision-frame,
+.semantic-review-card,
+.semantic-context-summary,
+.semantic-dev-details,
+.seo-chart,
+.market-panel,
+.market-heading,
+.market-state-card,
+.market-decision-board,
+.market-wordstat-card,
+  .market-provider,
+  .market-normalization-card,
+  .market-normalization-review-queue,
+  .keyword-page-plan-card,
+  .market-columns section,
+  .market-next-actions,
+  .market-seed-list div,
+  .market-brief-list div,
+  .keyword-page-phrase-list > div,
+  .keyword-next-action-list p,
+  .keyword-raw-grid > div,
+  .materialization-target {
+  border-radius: 22px !important;
+}
+
+.stage-decision-frame {
+  padding: 14px !important;
+  background: rgba(255, 255, 255, 0.92) !important;
+  box-shadow: var(--nodedc-glass-panel-shadow) !important;
+}
+
+.project-list-card,
+.project-row,
+.scan-summary,
+.semantic-panel,
+.market-panel,
+.market-heading,
+.market-state-card,
+.market-decision-board,
+.market-wordstat-card,
+  .market-provider,
+  .market-normalization-card,
+  .market-normalization-review-queue,
+  .keyword-page-plan-card,
+  .market-columns section,
+.market-next-actions,
+.semantic-dev-details,
+.semantic-context-summary {
+  overflow: visible !important;
+}
+
+.semantic-review-card.semantic-context-card {
+  color: var(--ink) !important;
+  background: rgba(255, 255, 255, 0.94) !important;
+  border: 0 !important;
+  box-shadow: var(--nodedc-glass-control-shadow) !important;
+}
+
+.semantic-context-summary {
+  background: rgba(255, 255, 255, 0.92) !important;
+  border: 0 !important;
+  box-shadow: var(--nodedc-glass-panel-shadow) !important;
+}
+
+.semantic-dev-details summary {
+  min-height: 42px;
+}
+
+.seo-chart {
+  background: rgba(255, 255, 255, 0.9) !important;
+  border: 0 !important;
+  box-shadow: var(--nodedc-glass-control-shadow) !important;
+}
+
+.market-columns section > div:first-child,
+.market-heading > div,
+.semantic-context-summary > div:first-child {
+  min-width: 0;
+}
+
+.market-columns section > div:first-child strong,
+.market-columns section > div:first-child small {
+  display: block;
+}
+
+.market-seed-list div,
+.market-brief-list div {
+  padding: 10px !important;
+}
+
+@media (max-width: 760px) {
+  .seo-shape-funnel-body,
+  .seo-ring-body,
+  .seo-radar-body {
+    grid-template-columns: 1fr;
+  }
+
+  .market-normalization-card {
+    flex-direction: column;
+  }
+
+  .market-normalization-groups {
+    grid-template-columns: 1fr;
+    width: 100%;
+    min-width: 0;
+  }
+
+  .market-normalization-review {
+    grid-template-columns: 1fr;
+  }
+
+  .market-decision-board,
+  .market-decision-metrics {
+    grid-template-columns: 1fr;
+  }
+
+  .semantic-context-summary {
+    grid-template-columns: 1fr;
+  }
+}
+
+/* Hub/Launcher shell adaptation for SEO Mode. */
+.seo-launcher-shell {
+  --nodedc-accent-rgb: 24 24 24;
+  --nodedc-on-accent-rgb: 247 248 244;
+  --nodedc-shell-padding-x: 1.25rem;
+  --nodedc-shell-padding-top: 1rem;
+  --nodedc-shell-padding-bottom: 0.75rem;
+  --nodedc-shell-frame-gutter-x: 18px;
+  --nodedc-shell-height: 4.25rem;
+  --nodedc-shell-row-height: 3rem;
+  --nodedc-shell-logo-width: 7.25rem;
+  --nodedc-shell-logo-height: 1.79rem;
+  --nodedc-shell-pill-height: 3.45rem;
+  --nodedc-shell-pill-padding: 0.32rem;
+  --nodedc-shell-control-height: 2.78rem;
+  --launcher-page-pad: 1.25rem;
+  --launcher-radius-card: 1.35rem;
+  --launcher-radius-control: 1.25rem;
+  --seo-shell-text: rgba(10, 12, 14, 0.94);
+  --seo-shell-muted: rgba(10, 12, 14, 0.56);
+  min-height: 100vh;
+  overflow-x: hidden;
+  background: #f2f2f2;
+}
+
+.seo-launcher-shell .app-header {
+  position: sticky !important;
+  top: 0;
+  z-index: 80;
+  display: block !important;
+  width: min(100%, calc(100vw - var(--nodedc-shell-frame-gutter-x))) !important;
+  margin-inline: auto !important;
+  padding: var(--nodedc-shell-padding-top) var(--nodedc-shell-padding-x) var(--nodedc-shell-padding-bottom) !important;
+  color: var(--seo-shell-text) !important;
+  background: transparent !important;
+  border: 0 !important;
+  box-shadow: none !important;
+}
+
+.seo-launcher-shell .nodedc-expanded-toolbar {
+  display: flex;
+  min-height: var(--nodedc-shell-height);
+  width: 100%;
+  flex-direction: column;
+}
+
+.seo-launcher-shell .nodedc-expanded-toolbar-top {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) auto minmax(0, 1fr);
+  min-height: var(--nodedc-shell-row-height);
+  width: 100%;
+  align-items: center;
+  gap: 1rem;
+}
+
+.seo-launcher-shell .nodedc-expanded-toolbar-left,
+.seo-launcher-shell .nodedc-expanded-toolbar-center,
+.seo-launcher-shell .nodedc-expanded-toolbar-right {
+  display: flex;
+  align-items: center;
+  gap: 0.75rem;
+  min-width: 0;
+}
+
+.seo-launcher-shell .nodedc-expanded-toolbar-left {
+  justify-content: flex-start;
+}
+
+.seo-launcher-shell .nodedc-expanded-toolbar-center {
+  justify-content: center;
+}
+
+.seo-launcher-shell .nodedc-expanded-toolbar-right {
+  justify-content: flex-end;
+}
+
+.seo-launcher-shell .nodedc-expanded-brand-link {
+  display: inline-flex;
+  width: var(--nodedc-shell-logo-width);
+  height: var(--nodedc-shell-logo-height);
+  align-items: center;
+  justify-content: flex-start;
+  line-height: 0;
+}
+
+.seo-launcher-shell .nodedc-expanded-brand-logo {
+  display: block;
+  width: 100%;
+  height: 100%;
+  object-fit: contain;
+  filter: invert(1);
+}
+
+.seo-launcher-shell .nodedc-expanded-nav-group,
+.seo-launcher-shell .nodedc-expanded-user-group,
+.seo-project-menu {
+  position: relative;
+  display: inline-flex;
+  min-height: var(--nodedc-shell-pill-height);
+  align-items: center;
+  gap: 0.18rem;
+  border: 0;
+  border-radius: 999px;
+  background: rgba(255, 255, 255, 0.7);
+  padding: var(--nodedc-shell-pill-padding);
+  box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.9), 0 18px 52px rgba(24, 32, 29, 0.12);
+  backdrop-filter: blur(24px) saturate(1.18);
+  -webkit-backdrop-filter: blur(24px) saturate(1.18);
+}
+
+.seo-launcher-shell .nodedc-expanded-user-group {
+  gap: 0.22rem;
+}
+
+.seo-launcher-shell .nodedc-expanded-nav-button,
+.seo-launcher-shell .nodedc-toolbar-icon-button {
+  position: relative;
+  display: inline-flex;
+  min-height: var(--nodedc-shell-control-height);
+  align-items: center;
+  justify-content: center;
+  gap: 0.34rem;
+  border: 0;
+  border-radius: 999px;
+  background: transparent;
+  color: rgba(10, 12, 14, 0.62);
+  padding: 0.2rem 1.22rem;
+  font-size: 0.74rem;
+  font-weight: 760;
+  line-height: 1;
+  white-space: nowrap;
+  box-shadow: none;
+  transition:
+    background-color 160ms ease,
+    color 160ms ease,
+    transform 160ms ease;
+}
+
+.seo-launcher-shell .nodedc-expanded-nav-button:hover,
+.seo-launcher-shell .nodedc-toolbar-icon-button:hover {
+  background: rgba(10, 12, 14, 0.06);
+  color: rgba(10, 12, 14, 0.94);
+}
+
+.seo-launcher-shell .nodedc-expanded-nav-button[data-active="true"] {
+  background: rgba(24, 24, 24, 0.94);
+  color: rgba(247, 248, 244, 0.96);
+}
+
+.seo-launcher-shell .nodedc-expanded-notification-button {
+  width: var(--nodedc-shell-control-height);
+  padding: 0;
+}
+
+.seo-launcher-shell .nodedc-toolbar-icon-active-dot {
+  display: grid;
+  width: 2rem;
+  height: 2rem;
+  place-items: center;
+  border-radius: 999px;
+}
+
+.seo-launcher-shell .nodedc-toolbar-icon-button[data-active="true"] .nodedc-toolbar-icon-active-dot {
+  background: rgba(24, 24, 24, 0.94);
+  color: rgba(247, 248, 244, 0.96);
+}
+
+.seo-launcher-shell .nodedc-expanded-profile-trigger {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.22rem;
+  border-radius: 999px;
+}
+
+.seo-launcher-shell .nodedc-expanded-user-avatar-button {
+  display: flex;
+  width: 3rem;
+  height: 3rem;
+  align-items: center;
+  justify-content: center;
+  overflow: hidden;
+  border-radius: 999px;
+  background: transparent;
+}
+
+.seo-launcher-shell .nodedc-expanded-user-avatar {
+  display: grid;
+  width: 3rem;
+  height: 3rem;
+  place-items: center;
+  border-radius: 999px;
+  background:
+    radial-gradient(circle at 70% 20%, rgba(255, 255, 255, 0.72), transparent 24%),
+    linear-gradient(135deg, rgb(226, 229, 218), rgb(168, 174, 164));
+  color: rgba(8, 8, 10, 0.96);
+  font-size: 0.78rem;
+  font-weight: 800;
+}
+
+.seo-project-menu-trigger svg {
+  transition: transform 160ms ease;
+}
+
+.seo-project-menu:has(.seo-project-menu-popover) .seo-project-menu-trigger svg {
+  transform: rotate(180deg);
+}
+
+.seo-project-menu-popover {
+  position: absolute;
+  z-index: 120;
+  top: calc(100% + 0.7rem);
+  left: 50%;
+  display: grid;
+  width: min(27rem, calc(100vw - 2rem));
+  gap: 0.7rem;
+  padding: 0.8rem;
+  border-radius: 1.35rem;
+  background: rgba(255, 255, 255, 0.92);
+  color: var(--seo-shell-text);
+  box-shadow: 0 28px 90px rgba(24, 32, 29, 0.24);
+  transform: translateX(-50%);
+  backdrop-filter: blur(28px) saturate(1.16);
+  -webkit-backdrop-filter: blur(28px) saturate(1.16);
+}
+
+.seo-project-menu-head {
+  display: grid;
+  gap: 0.2rem;
+  padding: 0.55rem 0.65rem;
+}
+
+.seo-project-menu-head span,
+.seo-project-menu-empty,
+.seo-project-menu-list button small {
+  color: var(--seo-shell-muted);
+  font-size: 0.74rem;
+  font-weight: 650;
+}
+
+.seo-project-menu-head strong {
+  color: var(--seo-shell-text);
+  font-size: 0.98rem;
+  line-height: 1.16;
+}
+
+.seo-project-menu-list {
+  display: grid;
+  max-height: min(22rem, 58vh);
+  gap: 0.38rem;
+  overflow: auto;
+  padding-right: 0.12rem;
+}
+
+.seo-project-menu-list button {
+  display: grid;
+  grid-template-columns: 1.9rem minmax(0, 1fr);
+  gap: 0.12rem 0.58rem;
+  min-height: 4rem;
+  align-items: center;
+  padding: 0.7rem;
+  border: 0;
+  border-radius: 1rem;
+  background: rgba(10, 12, 14, 0.045);
+  color: var(--seo-shell-text);
+  text-align: left;
+}
+
+.seo-project-menu-list button:hover,
+.seo-project-menu-list button.active {
+  background: rgba(10, 12, 14, 0.08);
+}
+
+.seo-project-menu-list button > span {
+  grid-row: 1 / span 2;
+  display: grid;
+  width: 1.9rem;
+  height: 1.9rem;
+  place-items: center;
+  border-radius: 999px;
+  background: rgba(255, 255, 255, 0.78);
+  color: rgba(10, 12, 14, 0.82);
+}
+
+.seo-project-menu-list button.active > span {
+  background: rgba(24, 24, 24, 0.94);
+  color: #fff;
+}
+
+.seo-project-menu-list button strong,
+.seo-project-menu-list button small {
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.seo-project-menu-add {
+  display: inline-flex;
+  min-height: 2.65rem;
+  align-items: center;
+  justify-content: center;
+  gap: 0.45rem;
+  border: 0;
+  border-radius: 999px;
+  background: rgba(24, 24, 24, 0.94);
+  color: #fff;
+  font-weight: 760;
+}
+
+.seo-project-menu-empty {
+  display: inline-flex;
+  min-height: 3.2rem;
+  align-items: center;
+  justify-content: center;
+  gap: 0.5rem;
+  border-radius: 1rem;
+  background: rgba(10, 12, 14, 0.045);
+}
+
+.seo-launcher-shell .workspace {
+  position: relative;
+  display: grid;
+  width: 100% !important;
+  min-height: calc(100vh - 6rem);
+  margin: 0 !important;
+  padding: 0 var(--launcher-page-pad) var(--launcher-page-pad) !important;
+  gap: 0 !important;
+  overflow: hidden;
+}
+
+.seo-launcher-shell.zero-state .workspace {
+  min-height: calc(100vh - 6rem);
+}
+
+.seo-zero-stage {
+  position: absolute;
+  inset: 0 var(--launcher-page-pad) var(--launcher-page-pad);
+  z-index: 0;
+  min-height: 0;
+}
+
+.seo-launcher-shell .stage-video-shell {
+  position: relative;
+  z-index: 2;
+  width: 100%;
+  height: 100%;
+  min-height: 0;
+  overflow: hidden;
+  border: 0;
+  border-radius: var(--launcher-radius-card);
+  background:
+    linear-gradient(180deg, rgba(255, 255, 255, 0.05), rgba(255, 255, 255, 0.012)),
+    rgba(20, 20, 25, 0.64);
+  box-shadow: 0 44px 150px rgba(24, 32, 29, 0.17);
+  isolation: isolate;
+}
+
+.seo-launcher-shell .stage-video-stream {
+  position: absolute;
+  inset: 0;
+  overflow: hidden;
+  background: #050506;
+}
+
+.seo-launcher-shell .stage-video-gif {
+  position: absolute;
+  inset: 0;
+  width: 100%;
+  height: 100%;
+  object-fit: cover;
+  opacity: 0.92;
+}
+
+.seo-launcher-shell .stage-video-stream::before {
+  position: absolute;
+  inset: -20%;
+  z-index: 1;
+  background:
+    linear-gradient(90deg, transparent 0 12%, rgba(255, 255, 255, 0.07) 12% 13%, transparent 13% 27%),
+    linear-gradient(180deg, transparent 0 18%, rgba(255, 255, 255, 0.05) 18% 19%, transparent 19% 32%);
+  background-size: 7rem 7rem;
+  content: "";
+  opacity: 0.34;
+  transform: rotate(-2deg);
+  mix-blend-mode: screen;
+}
+
+.seo-launcher-shell .stage-video-stream::after {
+  position: absolute;
+  inset: 0;
+  z-index: 2;
+  background:
+    radial-gradient(circle at 50% 50%, transparent 0 52%, rgba(0, 0, 0, 0.28) 100%),
+    linear-gradient(90deg, rgba(0, 0, 0, 0.28), transparent 18% 78%, rgba(0, 0, 0, 0.22));
+  content: "";
+}
+
+.seo-launcher-shell .stage-empty-title {
+  position: absolute;
+  z-index: 4;
+  top: 5.76rem;
+  left: 5.76rem;
+  display: grid;
+  gap: 0.22rem;
+  color: rgba(255, 255, 255, 0.94);
+  text-transform: uppercase;
+  pointer-events: none;
+}
+
+.seo-launcher-shell .stage-empty-title span,
+.seo-launcher-shell .stage-empty-title strong {
+  font-size: clamp(1.82rem, 2.3vw, 2.52rem);
+  font-weight: 350;
+  line-height: 1;
+}
+
+.seo-launcher-shell .stage-empty-title span {
+  color: rgba(64, 64, 64, 0.92);
+}
+
+.seo-launcher-shell .stage-empty-title strong {
+  color: rgba(255, 255, 255, 0.94);
+}
+
+.seo-launcher-shell.zero-state .topbar,
+.seo-launcher-shell.zero-state .flow-status-strip,
+.seo-launcher-shell.zero-state .project-setup > .section-heading,
+.seo-launcher-shell.zero-state .project-list-card {
+  display: none !important;
+}
+
+.seo-launcher-shell.zero-state .project-setup {
+  position: relative;
+  z-index: 3;
+  display: grid;
+  min-height: calc(100vh - 7.25rem);
+  place-items: center;
+  padding: 0 !important;
+  pointer-events: none;
+}
+
+.seo-launcher-shell.zero-state .project-grid {
+  display: grid;
+  width: min(28rem, calc(100vw - 3rem));
+  grid-template-columns: 1fr !important;
+  pointer-events: auto;
+}
+
+.seo-launcher-shell.zero-state .project-form {
+  display: grid !important;
+  gap: 1rem !important;
+  padding: 1rem !important;
+  border: 0 !important;
+  border-radius: 1.35rem !important;
+  background:
+    linear-gradient(180deg, rgba(255, 255, 255, 0.18), rgba(255, 255, 255, 0.06)),
+    rgba(247, 248, 244, 0.16) !important;
+  box-shadow: 0 28px 88px rgba(0, 0, 0, 0.34) !important;
+  backdrop-filter: blur(24px) saturate(1.1);
+  -webkit-backdrop-filter: blur(24px) saturate(1.1);
+}
+
+.seo-launcher-shell.zero-state .project-form .field > span {
+  display: none;
+}
+
+.seo-launcher-shell.zero-state .folder-picker-panel {
+  display: grid !important;
+  min-height: 14rem !important;
+  place-items: center !important;
+  align-content: center !important;
+  gap: 0.95rem !important;
+  border: 1px dashed rgba(255, 255, 255, 0.52) !important;
+  border-radius: 1.15rem !important;
+  background: rgba(255, 255, 255, 0.14) !important;
+  color: rgba(255, 255, 255, 0.86) !important;
+}
+
+.seo-launcher-shell.zero-state .folder-picker-panel::before {
+  display: grid;
+  width: 3.4rem;
+  height: 3.4rem;
+  place-items: center;
+  border-radius: 999px;
+  background: rgba(255, 255, 255, 0.86);
+  color: rgba(10, 12, 14, 0.94);
+  content: "+";
+  font-size: 2rem;
+  font-weight: 360;
+  line-height: 1;
+}
+
+.seo-launcher-shell.zero-state .folder-picker-panel .folder-pick-action {
+  min-height: 2.8rem !important;
+  padding: 0 1.2rem !important;
+  border-radius: 999px !important;
+  background: rgba(255, 255, 255, 0.92) !important;
+  color: rgba(10, 12, 14, 0.94) !important;
+  box-shadow: none !important;
+}
+
+.seo-launcher-shell.zero-state .folder-picker-panel > span {
+  max-width: 15rem;
+  color: rgba(255, 255, 255, 0.78) !important;
+  font-size: 0.88rem;
+  line-height: 1.22;
+  text-align: center;
+}
+
+.seo-launcher-shell.zero-state .project-form > .primary-action {
+  display: none !important;
+}
+
+.seo-launcher-shell.project-open .workspace {
+  grid-template-columns: clamp(17rem, 18vw, 21rem) minmax(0, 1fr);
+  grid-template-rows: auto auto minmax(0, 1fr);
+  column-gap: 1rem !important;
+  row-gap: 1rem !important;
+  align-items: start;
+  overflow: visible;
+}
+
+.seo-launcher-shell.project-open.work-fullscreen .workspace {
+  grid-template-columns: minmax(0, 1fr);
+}
+
+.seo-stage-rail {
+  position: sticky;
+  top: calc(var(--nodedc-shell-height) + 1.5rem);
+  z-index: 4;
+  grid-column: 1;
+  grid-row: 1 / 4;
+  display: grid;
+  max-height: calc(100vh - 7.4rem);
+  gap: 0.75rem;
+  overflow: hidden;
+  padding: 1rem;
+  border-radius: var(--launcher-radius-card);
+  background: rgba(255, 255, 255, 0.68);
+  box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.9), 0 24px 80px rgba(24, 32, 29, 0.1);
+  backdrop-filter: blur(24px) saturate(1.12);
+  -webkit-backdrop-filter: blur(24px) saturate(1.12);
+}
+
+.seo-launcher-shell.work-fullscreen .seo-stage-rail {
+  display: none;
+}
+
+.seo-stage-rail-head {
+  display: grid;
+  gap: 0.24rem;
+  padding: 0.35rem 0.45rem 0.7rem;
+}
+
+.seo-stage-rail-head span {
+  color: var(--seo-shell-muted);
+  font-size: 0.72rem;
+  font-weight: 760;
+  text-transform: uppercase;
+}
+
+.seo-stage-rail-head strong {
+  overflow: hidden;
+  color: var(--seo-shell-text);
+  font-size: 1.02rem;
+  line-height: 1.12;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.seo-stage-rail-head small {
+  color: var(--seo-shell-muted);
+  font-size: 0.78rem;
+}
+
+.seo-stage-rail-list {
+  display: grid;
+  gap: 0.36rem;
+  overflow: auto;
+  padding-right: 0.12rem;
+}
+
+.seo-stage-rail-list button {
+  display: grid;
+  grid-template-columns: 2rem minmax(0, 1fr);
+  gap: 0.16rem 0.65rem;
+  min-height: 4rem;
+  align-items: center;
+  padding: 0.58rem;
+  border: 0;
+  border-radius: 1rem;
+  background: rgba(10, 12, 14, 0.045);
+  color: var(--seo-shell-text);
+  text-align: left;
+}
+
+.seo-stage-rail-list button:hover:not(:disabled),
+.seo-stage-rail-list button.active {
+  background: rgba(10, 12, 14, 0.08);
+}
+
+.seo-stage-rail-list button.active {
+  box-shadow: inset 0 0 0 1px rgba(24, 24, 24, 0.12);
+}
+
+.seo-stage-rail-list button:disabled {
+  opacity: 0.46;
+}
+
+.seo-stage-rail-list button > span {
+  grid-row: 1 / span 2;
+  display: grid;
+  width: 2rem;
+  height: 2rem;
+  place-items: center;
+  border-radius: 999px;
+  background: rgba(255, 255, 255, 0.78);
+  color: rgba(10, 12, 14, 0.66);
+  font-size: 0.72rem;
+  font-weight: 850;
+}
+
+.seo-stage-rail-list button.active > span {
+  background: rgba(24, 24, 24, 0.94);
+  color: #fff;
+}
+
+.seo-stage-rail-list button strong,
+.seo-stage-rail-list button small {
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.seo-stage-rail-list button strong {
+  font-size: 0.88rem;
+  line-height: 1.12;
+}
+
+.seo-stage-rail-list button small {
+  color: var(--seo-shell-muted);
+  font-size: 0.72rem;
+  line-height: 1.18;
+}
+
+.seo-launcher-shell.project-open .topbar,
+.seo-launcher-shell.project-open .flow-status-strip,
+.seo-launcher-shell.project-open .project-setup {
+  grid-column: 2;
+  min-width: 0;
+}
+
+.seo-launcher-shell.project-open .topbar {
+  grid-row: 1;
+}
+
+.seo-launcher-shell.project-open .flow-status-strip {
+  grid-row: 2;
+}
+
+.seo-launcher-shell.project-open .project-setup {
+  grid-row: 3;
+}
+
+.seo-launcher-shell.project-open.work-fullscreen .topbar,
+.seo-launcher-shell.project-open.work-fullscreen .flow-status-strip,
+.seo-launcher-shell.project-open.work-fullscreen .project-setup {
+  grid-column: 1;
+}
+
+.seo-launcher-shell.project-open .topbar {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) auto auto;
+  align-items: center;
+  gap: 0.75rem;
+  margin-bottom: 1rem;
+  padding: 0.95rem 1rem;
+  border: 0;
+  border-radius: var(--launcher-radius-card);
+  background: rgba(255, 255, 255, 0.74);
+  box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.92), 0 24px 80px rgba(24, 32, 29, 0.09);
+  backdrop-filter: blur(24px) saturate(1.12);
+  -webkit-backdrop-filter: blur(24px) saturate(1.12);
+}
+
+.seo-launcher-shell.project-open .topbar::after {
+  display: none !important;
+}
+
+.seo-launcher-shell.project-open .topbar h2 {
+  font-size: 1.4rem !important;
+}
+
+.seo-work-panel-actions {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.35rem;
+  padding: 0.18rem;
+  border-radius: 999px;
+  background: rgba(10, 12, 14, 0.06);
+}
+
+.seo-work-panel-actions button {
+  display: grid;
+  width: 2.42rem;
+  height: 2.42rem;
+  place-items: center;
+  border: 0;
+  border-radius: 999px;
+  background: rgba(255, 255, 255, 0.8);
+  color: rgba(10, 12, 14, 0.74);
+}
+
+.seo-work-panel-actions button:hover {
+  background: rgba(24, 24, 24, 0.94);
+  color: #fff;
+}
+
+.seo-work-panel-actions button:focus,
+.seo-work-panel-actions button:focus-visible,
+.seo-stage-rail-list button:focus,
+.seo-stage-rail-list button:focus-visible {
+  outline: none;
+}
+
+.seo-work-panel-actions button:focus-visible {
+  box-shadow:
+    inset 0 0 0 1px rgba(10, 12, 14, 0.16),
+    0 10px 30px rgba(24, 32, 29, 0.08);
+}
+
+.seo-launcher-shell.project-open .project-setup {
+  padding: 1rem !important;
+  border-radius: var(--launcher-radius-card);
+  background: rgba(255, 255, 255, 0.74) !important;
+  box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.92), 0 24px 80px rgba(24, 32, 29, 0.09) !important;
+  backdrop-filter: blur(24px) saturate(1.08);
+  -webkit-backdrop-filter: blur(24px) saturate(1.08);
+}
+
+.seo-launcher-shell.project-open .project-setup > .section-heading {
+  padding: 0.15rem 0.15rem 0.85rem !important;
+}
+
+.seo-launcher-shell.project-open .project-grid {
+  gap: 1rem !important;
+}
+
+.seo-launcher-shell.project-open .project-form {
+  display: none !important;
+}
+
+.seo-launcher-shell.project-open .project-list-card {
+  padding: 0 !important;
+  border: 0 !important;
+  border-radius: 0 !important;
+  background: transparent !important;
+  box-shadow: none !important;
+}
+
+.seo-project-name-modal-backdrop {
+  position: fixed;
+  inset: 0;
+  z-index: 140;
+  display: grid;
+  place-items: center;
+  padding: 1rem;
+  background: rgba(10, 12, 14, 0.38);
+  backdrop-filter: blur(18px);
+  -webkit-backdrop-filter: blur(18px);
+}
+
+.seo-project-name-modal {
+  display: grid;
+  width: min(30rem, 100%);
+  gap: 1rem;
+  padding: 1rem;
+  border: 0;
+  border-radius: 1.35rem;
+  background: rgba(255, 255, 255, 0.94);
+  box-shadow: 0 30px 110px rgba(0, 0, 0, 0.3);
+}
+
+.seo-project-name-modal-head {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 0.8rem;
+}
+
+.seo-project-name-modal-head span {
+  color: var(--seo-shell-muted);
+  font-size: 0.76rem;
+  font-weight: 760;
+  text-transform: uppercase;
+}
+
+.seo-project-name-modal-head button {
+  display: grid;
+  width: 2.3rem;
+  height: 2.3rem;
+  place-items: center;
+  border: 0;
+  border-radius: 999px;
+  background: rgba(10, 12, 14, 0.06);
+  color: rgba(10, 12, 14, 0.78);
+}
+
+.seo-project-name-modal .service-field input {
+  min-height: 3rem;
+  border-radius: 1rem;
+}
+
+.seo-project-name-modal-actions {
+  display: flex;
+  justify-content: flex-end;
+  gap: 0.6rem;
+}
+
+.seo-project-name-modal-actions .primary-action {
+  width: auto;
+  min-height: 2.65rem;
+  padding-inline: 1.25rem;
+}
+
+@media (max-width: 980px) {
+  .seo-launcher-shell.project-open .workspace {
+    grid-template-columns: 1fr;
+  }
+
+  .seo-stage-rail {
+    position: relative;
+    top: auto;
+    max-height: none;
+  }
+
+  .seo-launcher-shell.project-open .topbar,
+  .seo-launcher-shell.project-open .flow-status-strip,
+  .seo-launcher-shell.project-open .project-setup {
+    grid-column: 1;
+  }
+}
+
+@media (max-width: 720px) {
+  .seo-launcher-shell .nodedc-expanded-toolbar-top {
+    grid-template-columns: 1fr;
+    justify-items: center;
+  }
+
+  .seo-launcher-shell .nodedc-expanded-toolbar-left,
+  .seo-launcher-shell .nodedc-expanded-toolbar-center,
+  .seo-launcher-shell .nodedc-expanded-toolbar-right {
+    justify-content: center;
+  }
+
+  .seo-launcher-shell .stage-empty-title {
+    top: 2rem;
+    left: 2rem;
+  }
+
+  .seo-launcher-shell.zero-state .project-setup {
+    min-height: calc(100vh - 12rem);
+  }
+
+  .seo-launcher-shell.project-open .topbar {
+    grid-template-columns: 1fr;
+  }
+}
+
+/* Launcher geometry correction: viewport is fixed; only inner panels scroll. */
+html:has(.seo-launcher-shell),
+body:has(.seo-launcher-shell),
+#root:has(.seo-launcher-shell) {
+  height: 100%;
+  overflow: hidden;
+}
+
+body:has(.seo-launcher-shell) {
+  background: #f2f2f2;
+}
+
+.seo-launcher-shell {
+  --seo-shell-occupied-top: calc(
+    var(--nodedc-shell-height) + var(--nodedc-shell-padding-top) + var(--nodedc-shell-padding-bottom)
+  );
+  --seo-work-nav-width: clamp(20.75rem, 19.5vw, 22rem);
+  --seo-work-panel-gap: 1.2rem;
+  --seo-admin-nav-pad: 1.1rem;
+  --seo-admin-control-ring: 2.92rem;
+  --seo-admin-control-inset: 5px;
+  height: 100vh;
+  min-height: 0;
+  overflow: hidden;
+}
+
+.seo-launcher-shell .workspace {
+  position: relative !important;
+  display: block !important;
+  width: 100% !important;
+  height: calc(100vh - var(--seo-shell-occupied-top)) !important;
+  min-height: 0 !important;
+  margin: 0 !important;
+  padding: 0 !important;
+  overflow: hidden !important;
+}
+
+.seo-launcher-shell .footer-line {
+  display: none !important;
+}
+
+.seo-zero-stage {
+  inset: 0 var(--launcher-page-pad) var(--launcher-page-pad) !important;
+}
+
+.seo-work-panel {
+  position: absolute;
+  z-index: 5;
+  top: 0;
+  right: var(--launcher-page-pad);
+  bottom: var(--launcher-page-pad);
+  left: calc(var(--launcher-page-pad) + var(--seo-work-nav-width) + var(--seo-work-panel-gap));
+  display: grid;
+  grid-template-rows: auto minmax(0, 1fr);
+  min-width: 0;
+  overflow: hidden;
+  border: 0;
+  border-radius: var(--launcher-radius-card);
+  background: rgba(255, 255, 255, 0.76);
+  box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.92), 0 34px 110px rgba(24, 32, 29, 0.12);
+  backdrop-filter: blur(28px) saturate(1.12);
+  -webkit-backdrop-filter: blur(28px) saturate(1.12);
+  animation: seoPanelSlide 460ms cubic-bezier(0.22, 1, 0.36, 1) both;
+}
+
+.seo-launcher-shell.work-fullscreen .seo-work-panel {
+  left: var(--launcher-page-pad);
+}
+
+.seo-launcher-shell.zero-state .seo-work-panel {
+  inset: 0 var(--launcher-page-pad) var(--launcher-page-pad);
+  display: grid;
+  grid-template-rows: 1fr !important;
+  place-items: center;
+  background: transparent;
+  box-shadow: none;
+  backdrop-filter: none;
+  -webkit-backdrop-filter: none;
+  pointer-events: none;
+  animation: none;
+}
+
+.seo-launcher-shell.zero-state .seo-work-panel .project-setup {
+  pointer-events: none;
+}
+
+.seo-launcher-shell.zero-state .project-grid {
+  pointer-events: auto;
+}
+
+.seo-launcher-shell.zero-state .project-setup {
+  align-self: center !important;
+  justify-self: center !important;
+  width: min(28rem, calc(100vw - 3rem)) !important;
+  min-height: 0 !important;
+  height: auto !important;
+  place-items: center !important;
+}
+
+.seo-launcher-shell.project-open .seo-stage-rail {
+  position: absolute !important;
+  z-index: 6;
+  top: 0;
+  bottom: var(--launcher-page-pad);
+  left: var(--launcher-page-pad);
+  width: var(--seo-work-nav-width);
+  max-height: none;
+  min-height: 0;
+  grid-row: auto;
+  grid-column: auto;
+  grid-template-rows: auto minmax(0, 1fr);
+  animation: seoPanelSlide 420ms cubic-bezier(0.22, 1, 0.36, 1) both;
+}
+
+.seo-launcher-shell.work-fullscreen .seo-stage-rail {
+  display: none !important;
+}
+
+.seo-stage-rail {
+  padding: var(--seo-admin-nav-pad);
+}
+
+.seo-stage-rail-head {
+  padding: 0.55rem 0.55rem 0.9rem;
+}
+
+.seo-stage-rail-list {
+  width: calc(100% + (var(--seo-admin-nav-pad) * 2));
+  margin-inline: calc(var(--seo-admin-nav-pad) * -1);
+  min-height: 0;
+  overflow: auto;
+  scrollbar-width: none;
+}
+
+.seo-stage-rail-list::-webkit-scrollbar {
+  display: none;
+}
+
+.seo-stage-rail-list button {
+  position: relative;
+  display: grid;
+  grid-template-columns: minmax(0, 1fr);
+  min-height: calc(var(--seo-admin-control-ring) + (var(--seo-admin-control-inset) * 2));
+  align-content: center;
+  padding: var(--seo-admin-control-inset) 0.9rem var(--seo-admin-control-inset)
+    calc(var(--seo-admin-control-inset) + var(--seo-admin-control-ring) + 0.86rem);
+  border-radius: 999px;
+  background: rgba(10, 12, 14, 0.045);
+  color: rgba(10, 12, 14, 0.72);
+  box-shadow: none;
+  opacity: 0.9;
+  transition:
+    background 160ms ease,
+    color 160ms ease,
+    opacity 160ms ease,
+    transform 160ms ease,
+    box-shadow 160ms ease;
+}
+
+.seo-stage-rail-list button:hover:not(:disabled) {
+  background: rgba(10, 12, 14, 0.075);
+  color: rgba(8, 8, 10, 0.95);
+  opacity: 1;
+  transform: translateY(-1px);
+}
+
+.seo-stage-rail-list button.active {
+  background: rgba(10, 12, 14, 0.095);
+  color: rgba(8, 8, 10, 0.98);
+  box-shadow: inset 0 0 0 1px rgba(24, 24, 24, 0.12);
+  opacity: 1;
+}
+
+.seo-stage-rail-list button > span {
+  position: absolute;
+  top: 50%;
+  left: var(--seo-admin-control-inset);
+  width: var(--seo-admin-control-ring);
+  height: var(--seo-admin-control-ring);
+  transform: translateY(-50%);
+  box-shadow:
+    inset 0 1px 0 rgba(255, 255, 255, 0.64),
+    0 8px 20px rgba(20, 24, 22, 0.08);
+}
+
+.seo-stage-rail-list button strong,
+.seo-stage-rail-list button small {
+  grid-column: 1;
+}
+
+.seo-launcher-shell.project-open .topbar {
+  position: relative;
+  z-index: 2;
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) auto;
+  grid-row: auto;
+  grid-column: auto;
+  align-items: center;
+  gap: 1rem;
+  min-height: 5.6rem;
+  margin: 0;
+  padding: 1.15rem 1.15rem 0.75rem;
+  border: 0;
+  border-radius: 0;
+  background: transparent;
+  box-shadow: none;
+  backdrop-filter: none;
+  -webkit-backdrop-filter: none;
+}
+
+.seo-launcher-shell.project-open .topbar h2 {
+  max-width: 56rem;
+  font-size: 1.42rem !important;
+  line-height: 1.1;
+}
+
+.seo-launcher-shell.project-open .topbar .eyebrow {
+  color: var(--seo-shell-muted);
+}
+
+.seo-launcher-shell.project-open .flow-status-strip {
+  display: none !important;
+}
+
+.seo-work-panel-actions {
+  display: inline-flex;
+  align-items: center;
+  justify-content: flex-end;
+  gap: 0.5rem;
+  padding: 0;
+  border-radius: 999px;
+  background: transparent;
+}
+
+.seo-work-panel-actions button {
+  display: grid;
+  width: 3rem;
+  height: 3rem;
+  place-items: center;
+  border-radius: 999px;
+  border: 0;
+  background: rgba(255, 255, 255, 0.9);
+  color: rgba(10, 12, 14, 0.84);
+  box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.94), 0 10px 30px rgba(24, 32, 29, 0.08);
+}
+
+.seo-work-panel-actions button:last-child {
+  background: rgba(255, 255, 255, 0.42);
+  box-shadow: inset 0 0 0 1px rgba(10, 12, 14, 0.08);
+}
+
+.seo-work-panel-actions button:hover {
+  background: rgba(24, 24, 24, 0.94);
+  color: #fff;
+}
+
+.seo-launcher-shell.project-open .project-setup {
+  grid-row: auto;
+  grid-column: auto;
+  min-height: 0;
+  overflow: auto;
+  padding: 0 1.15rem 1.15rem !important;
+  border-radius: 0;
+  background: transparent !important;
+  box-shadow: none !important;
+  backdrop-filter: none;
+  -webkit-backdrop-filter: none;
+  scrollbar-width: thin;
+}
+
+.seo-launcher-shell.project-open .project-setup > .section-heading {
+  display: grid;
+  grid-template-columns: auto minmax(0, 1fr);
+  align-items: start;
+  gap: 0.8rem;
+  margin: 0 0 1rem;
+  padding: 0.55rem 0.15rem 0.9rem !important;
+  border-bottom: 1px solid rgba(10, 12, 14, 0.08);
+}
+
+.seo-launcher-shell.project-open .project-setup > .section-heading h3 {
+  font-size: 1.2rem;
+  line-height: 1.12;
+}
+
+.seo-launcher-shell.project-open .project-setup > .section-heading p {
+  max-width: 62rem;
+  margin-top: 0.28rem;
+}
+
+.seo-stage-summary-row {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.45rem;
+  margin-top: 0.7rem;
+}
+
+.seo-stage-summary-row span {
+  display: inline-flex;
+  min-height: 1.6rem;
+  align-items: center;
+  padding: 0 0.62rem;
+  border-radius: 999px;
+  background: rgba(38, 104, 74, 0.09);
+  color: #2c6a51;
+  font-size: 0.72rem;
+  font-weight: 850;
+  line-height: 1;
+  white-space: nowrap;
+}
+
+.seo-launcher-shell.project-open .project-grid {
+  min-height: 0;
+  gap: 0 !important;
+}
+
+.seo-launcher-shell.project-open .project-list-card {
+  min-height: 0;
+  overflow: visible !important;
+}
+
+.seo-launcher-shell.project-open .project-row {
+  min-height: 0;
+  padding: 0 !important;
+  border: 0 !important;
+  border-radius: 0 !important;
+  background: transparent !important;
+  box-shadow: none !important;
+}
+
+.seo-launcher-shell.project-open .project-row > div:first-child > .project-title-row,
+.seo-launcher-shell.project-open .project-row > div:first-child > .project-source,
+.seo-launcher-shell.project-open .project-row > div:first-child > .project-scan-status {
+  display: none !important;
+}
+
+.seo-header-mode-switch {
+  min-height: var(--nodedc-shell-pill-height) !important;
+  padding: var(--nodedc-shell-pill-padding) !important;
+  border: 0 !important;
+  border-radius: 999px !important;
+  background: rgba(255, 255, 255, 0.7) !important;
+  box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.9), 0 18px 52px rgba(24, 32, 29, 0.12) !important;
+  backdrop-filter: blur(24px) saturate(1.18);
+  -webkit-backdrop-filter: blur(24px) saturate(1.18);
+}
+
+.seo-header-mode-switch button {
+  min-height: var(--nodedc-shell-control-height) !important;
+  padding: 0.2rem 1.22rem !important;
+  border-radius: 999px !important;
+  border: 0 !important;
+  background: transparent !important;
+  color: rgba(10, 12, 14, 0.62) !important;
+  box-shadow: none !important;
+  font-size: 0.74rem !important;
+  font-weight: 760 !important;
+}
+
+.seo-header-mode-switch button.active {
+  background: rgba(255, 255, 255, 0.96) !important;
+  color: rgba(8, 8, 10, 0.96) !important;
+}
+
+.seo-launcher-shell .nodedc-expanded-toolbar-center {
+  gap: 0.65rem;
+}
+
+@keyframes seoPanelSlide {
+  from {
+    opacity: 0;
+    transform: translateX(-1.25rem);
+  }
+  to {
+    opacity: 1;
+    transform: translateX(0);
+  }
+}
+
+@media (max-width: 980px) {
+  .seo-work-panel,
+  .seo-launcher-shell.work-fullscreen .seo-work-panel {
+    left: var(--launcher-page-pad);
+  }
+
+  .seo-launcher-shell.project-open .seo-stage-rail {
+    display: none;
+  }
+}
+
+/* Launcher panel model: video stage is persistent; nav/content panels slide over it. */
+.seo-launcher-shell {
+  --seo-work-content-width: calc(
+    100vw - (var(--launcher-page-pad) * 2) - (var(--seo-work-panel-gap) * 2) - (var(--seo-work-nav-width) * 2)
+  );
+}
+
+.seo-zero-stage {
+  position: absolute !important;
+  z-index: 1;
+  inset: 0 !important;
+  display: grid;
+  min-width: 0;
+  min-height: 0;
+  overflow: hidden;
+  padding: 0 var(--launcher-page-pad) var(--launcher-page-pad);
+  transition:
+    padding-left 440ms cubic-bezier(0.22, 1, 0.36, 1),
+    transform 440ms cubic-bezier(0.22, 1, 0.36, 1);
+}
+
+.seo-zero-stage .stage-video-shell {
+  width: 100%;
+  height: 100%;
+  min-width: 0;
+  min-height: 0;
+}
+
+.seo-launcher-shell.project-open .seo-zero-stage {
+  padding-left: calc(var(--launcher-page-pad) + var(--seo-work-nav-width) + var(--seo-work-panel-gap));
+}
+
+.seo-launcher-shell.project-open.content-open .seo-zero-stage {
+  padding-left: calc(
+    var(--launcher-page-pad) + var(--seo-work-nav-width) + var(--seo-work-panel-gap) + var(--seo-work-content-width) +
+      var(--seo-work-panel-gap)
+  );
+}
+
+.seo-launcher-shell.project-open.work-fullscreen .seo-zero-stage {
+  transform: translateX(calc(100vw + var(--launcher-page-pad)));
+  pointer-events: none;
+}
+
+.seo-launcher-shell.zero-state .seo-zero-stage {
+  padding-left: var(--launcher-page-pad);
+}
+
+.seo-launcher-shell.project-open .seo-stage-rail {
+  position: absolute !important;
+  z-index: 8;
+  top: 0;
+  bottom: var(--launcher-page-pad);
+  left: var(--launcher-page-pad);
+  display: grid;
+  width: var(--seo-work-nav-width);
+  min-width: var(--seo-work-nav-width);
+  grid-template-rows: auto minmax(0, 1fr);
+  gap: 1.05rem;
+  padding: var(--seo-admin-nav-pad);
+  border-radius: var(--launcher-radius-card);
+  background:
+    linear-gradient(180deg, rgba(255, 255, 255, 0.74), rgba(255, 255, 255, 0.54)),
+    rgba(255, 255, 255, 0.72);
+  box-shadow: 0 34px 110px rgba(24, 32, 29, 0.14);
+  backdrop-filter: blur(28px);
+  -webkit-backdrop-filter: blur(28px);
+  animation: seoPanelSlide 420ms cubic-bezier(0.22, 1, 0.36, 1) both;
+}
+
+.seo-stage-rail-list {
+  display: grid !important;
+  width: calc(100% + (var(--seo-admin-nav-pad) * 2)) !important;
+  margin-inline: calc(var(--seo-admin-nav-pad) * -1) !important;
+  align-content: start !important;
+  align-items: start !important;
+  grid-auto-rows: max-content !important;
+  gap: 0.22rem !important;
+  overflow-x: visible !important;
+  overflow-y: auto !important;
+}
+
+.seo-stage-rail-list button {
+  width: 100% !important;
+  min-height: calc(var(--seo-admin-control-ring) + (var(--seo-admin-control-inset) * 2)) !important;
+  height: auto !important;
+  max-height: calc(var(--seo-admin-control-ring) + (var(--seo-admin-control-inset) * 2)) !important;
+  align-content: center !important;
+  justify-content: start !important;
+  border-radius: 999px !important;
+  overflow: hidden;
+}
+
+.seo-stage-rail-list button > span {
+  display: grid !important;
+  place-items: center !important;
+  width: var(--seo-admin-control-ring) !important;
+  height: var(--seo-admin-control-ring) !important;
+}
+
+.seo-stage-rail-list button strong {
+  font-size: 0.91rem !important;
+  line-height: 1.08 !important;
+}
+
+.seo-stage-rail-list button small {
+  font-size: 0.72rem !important;
+  line-height: 1.05 !important;
+}
+
+.seo-launcher-shell.content-open .seo-work-panel {
+  position: absolute;
+  z-index: 9;
+  top: 0;
+  right: auto;
+  bottom: var(--launcher-page-pad);
+  left: calc(var(--launcher-page-pad) + var(--seo-work-nav-width) + var(--seo-work-panel-gap));
+  display: grid;
+  width: var(--seo-work-content-width);
+  min-width: 0;
+  grid-template-rows: auto minmax(0, 1fr);
+  overflow: hidden;
+  padding: 0;
+  border-radius: var(--launcher-radius-card);
+  background:
+    linear-gradient(180deg, rgba(255, 255, 255, 0.82), rgba(255, 255, 255, 0.66)),
+    rgba(255, 255, 255, 0.76);
+  box-shadow: none;
+  backdrop-filter: blur(28px);
+  -webkit-backdrop-filter: blur(28px);
+  animation: seoPanelSlide 460ms cubic-bezier(0.22, 1, 0.36, 1) 120ms both;
+}
+
+.seo-launcher-shell.work-fullscreen.content-open .seo-work-panel {
+  right: var(--launcher-page-pad);
+  left: var(--launcher-page-pad);
+  width: auto;
+  animation-delay: 0ms;
+}
+
+.seo-launcher-shell.work-fullscreen .seo-stage-rail {
+  display: none !important;
+}
+
+.seo-launcher-shell.zero-state .seo-work-panel {
+  z-index: 5;
+}
+
+.seo-launcher-shell.project-open:not(.content-open) .seo-work-panel {
+  display: none !important;
+}
+
+@media (max-width: 980px) {
+  .seo-launcher-shell.project-open .seo-zero-stage,
+  .seo-launcher-shell.project-open.content-open .seo-zero-stage {
+    padding-left: var(--launcher-page-pad);
+  }
+
+  .seo-launcher-shell.content-open .seo-work-panel,
+  .seo-launcher-shell.work-fullscreen.content-open .seo-work-panel {
+    right: var(--launcher-page-pad);
+    left: var(--launcher-page-pad);
+    width: auto;
+  }
+}
+
+/* Launcher UX pass: glass controls, hidden right video tail, compact stage 2 editor. */
+.seo-launcher-shell.zero-state .project-grid {
+  width: min(29rem, calc(100vw - 3rem)) !important;
+}
+
+.seo-launcher-shell.zero-state .project-form {
+  width: 100% !important;
+  padding: 0 !important;
+  border: 0 !important;
+  background: transparent !important;
+  box-shadow: none !important;
+  backdrop-filter: none !important;
+  -webkit-backdrop-filter: none !important;
+}
+
+.seo-launcher-shell.zero-state .project-form .field {
+  margin: 0 !important;
+}
+
+.seo-launcher-shell.zero-state .folder-picker-panel {
+  width: 100% !important;
+  min-height: 13.9rem !important;
+  padding: 1.05rem !important;
+  place-items: center !important;
+  align-content: center !important;
+  justify-content: center !important;
+  gap: 0.78rem !important;
+  border: 1px dashed rgba(255, 255, 255, 0.58) !important;
+  border-radius: 1.22rem !important;
+  background:
+    linear-gradient(180deg, rgba(255, 255, 255, 0.24), rgba(255, 255, 255, 0.1)),
+    rgba(238, 239, 234, 0.18) !important;
+  box-shadow:
+    inset 0 1px 0 rgba(255, 255, 255, 0.62),
+    0 28px 88px rgba(24, 28, 26, 0.26) !important;
+  backdrop-filter: blur(28px) saturate(1.16) !important;
+  -webkit-backdrop-filter: blur(28px) saturate(1.16) !important;
+}
+
+.seo-launcher-shell.zero-state .folder-picker-panel::before {
+  order: 1;
+  margin: 0 auto !important;
+}
+
+.seo-launcher-shell.zero-state .folder-picker-panel > span {
+  order: 2;
+  margin: 0 auto !important;
+}
+
+.seo-launcher-shell.zero-state .folder-picker-panel .folder-pick-action {
+  order: 3;
+  margin: 0 auto !important;
+}
+
+.seo-project-menu-trigger svg {
+  display: none !important;
+}
+
+.seo-project-menu-popover {
+  left: calc(100% - 0.45rem) !important;
+  right: auto !important;
+  top: calc(100% + 0.65rem) !important;
+  transform: none !important;
+  width: min(27rem, calc(100vw - 3rem)) !important;
+  border: 1px solid rgba(255, 255, 255, 0.42) !important;
+  background:
+    linear-gradient(180deg, rgba(255, 255, 255, 0.48), rgba(255, 255, 255, 0.24)),
+    rgba(243, 244, 241, 0.34) !important;
+  box-shadow:
+    inset 0 1px 0 rgba(255, 255, 255, 0.72),
+    0 30px 90px rgba(24, 28, 26, 0.24) !important;
+  backdrop-filter: blur(30px) saturate(1.16) !important;
+  -webkit-backdrop-filter: blur(30px) saturate(1.16) !important;
+}
+
+.seo-project-menu-list button {
+  background: rgba(255, 255, 255, 0.36) !important;
+}
+
+.seo-project-menu-list button:hover,
+.seo-project-menu-list button.active {
+  background: rgba(255, 255, 255, 0.58) !important;
+}
+
+.seo-project-menu-add {
+  background: rgba(24, 24, 24, 0.94) !important;
+}
+
+.seo-header-mode-switch button.active {
+  background: rgba(24, 24, 24, 0.94) !important;
+  color: #ffffff !important;
+}
+
+.seo-launcher-shell.project-open.content-open .seo-zero-stage {
+  transform: translateX(calc(100vw + var(--launcher-page-pad)));
+  pointer-events: none;
+}
+
+.seo-launcher-shell.project-open.content-open .seo-work-panel {
+  right: var(--launcher-page-pad) !important;
+  width: auto !important;
+}
+
+.seo-launcher-shell .workspace.stage-2 .project-setup {
+  display: grid !important;
+  height: 100% !important;
+  min-height: 0 !important;
+  grid-template-rows: minmax(0, 1fr);
+  overflow: hidden !important;
+  padding: 0 1rem 1rem !important;
+}
+
+.seo-launcher-shell .workspace.stage-2 .project-grid,
+.seo-launcher-shell .workspace.stage-2 .project-list-card,
+.seo-launcher-shell .workspace.stage-2 .project-list,
+.seo-launcher-shell .workspace.stage-2 .project-row,
+.seo-launcher-shell .workspace.stage-2 .project-row > div:first-child,
+.seo-launcher-shell .workspace.stage-2 .page-audit-overview {
+  display: grid !important;
+  height: 100% !important;
+  min-height: 0 !important;
+  grid-template-rows: minmax(0, 1fr);
+  overflow: hidden !important;
+}
+
+.seo-launcher-shell .workspace.stage-2 .page-audit-summary,
+.seo-launcher-shell .workspace.stage-2 .configuration-confirm-bar,
+.seo-launcher-shell .workspace.stage-2 .engineering-page-list {
+  display: none !important;
+}
+
+.seo-launcher-shell .workspace.stage-2 .project-scope-flow-panel {
+  display: grid !important;
+  height: 100% !important;
+  min-height: 0 !important;
+  grid-template-rows: minmax(0, 1fr) !important;
+  gap: 0 !important;
+  padding: 0 !important;
+  border: 0 !important;
+  background: transparent !important;
+  box-shadow: none !important;
+}
+
+.seo-launcher-shell .workspace.stage-2 .project-scope-flow-controls {
+  display: flex !important;
+  align-items: center !important;
+  justify-content: space-between !important;
+  gap: 1rem !important;
+  min-height: 4.25rem;
+  padding: 0.78rem 0.85rem !important;
+  border: 1px solid rgba(31, 42, 37, 0.08);
+  border-radius: 1rem;
+  background: rgba(255, 255, 255, 0.64);
+  box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.9);
+  backdrop-filter: blur(18px) saturate(1.08);
+  -webkit-backdrop-filter: blur(18px) saturate(1.08);
+}
+
+.project-scope-flow-confirm-copy {
+  display: grid;
+  min-width: 0;
+  gap: 0.12rem;
+}
+
+.project-scope-flow-confirm-copy span {
+  color: #3b6470;
+  font-size: 0.68rem;
+  font-weight: 860;
+  letter-spacing: 0;
+  text-transform: uppercase;
+}
+
+.project-scope-flow-confirm-copy strong {
+  color: rgba(8, 8, 10, 0.96);
+  font-size: 0.98rem;
+  line-height: 1.08;
+}
+
+.project-scope-flow-confirm-copy small {
+  overflow: hidden;
+  color: rgba(8, 8, 10, 0.56);
+  font-size: 0.76rem;
+  line-height: 1.16;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.project-scope-flow-confirm-action {
+  display: inline-flex;
+  min-height: 2.65rem;
+  align-items: center;
+  justify-content: center;
+  gap: 0.45rem;
+  padding: 0 1.15rem;
+  border: 0;
+  border-radius: 999px;
+  background: rgba(24, 24, 24, 0.94);
+  color: #fff;
+  font-size: 0.86rem;
+  font-weight: 820;
+  white-space: nowrap;
+}
+
+.project-scope-flow-confirm-action:disabled {
+  cursor: not-allowed;
+  background: rgba(10, 12, 14, 0.12);
+  color: rgba(10, 12, 14, 0.42);
+}
+
+.seo-launcher-shell .workspace.stage-2 .project-scope-flow-canvas {
+  height: 100% !important;
+  min-height: 0 !important;
+  border-radius: 1rem !important;
+}
+
+.project-scope-flow-stats {
+  position: absolute;
+  z-index: 12;
+  top: 0.78rem;
+  left: 0.78rem;
+  display: flex;
+  max-width: calc(100% - 1.56rem);
+  flex-wrap: wrap;
+  gap: 0.42rem;
+  pointer-events: none;
+}
+
+.project-scope-flow-stats span {
+  display: inline-flex;
+  min-height: 2.2rem;
+  align-items: center;
+  gap: 0.42rem;
+  padding: 0 0.74rem;
+  border: 1px solid rgba(31, 42, 37, 0.08);
+  border-radius: 999px;
+  background: rgba(255, 255, 255, 0.78);
+  color: rgba(10, 12, 14, 0.64);
+  box-shadow: 0 10px 30px rgba(24, 32, 29, 0.08);
+  font-size: 0.75rem;
+  font-weight: 800;
+  line-height: 1;
+  white-space: nowrap;
+  backdrop-filter: blur(16px);
+  -webkit-backdrop-filter: blur(16px);
+}
+
+/* Work panels: the header is part of the same surface, not a separate card. */
+.seo-launcher-shell.project-open .topbar {
+  display: grid !important;
+  grid-template-columns: minmax(0, 1fr) auto !important;
+  align-items: center !important;
+  gap: 1rem !important;
+  min-height: 5.45rem !important;
+  padding: 1.05rem 1.15rem 0.85rem !important;
+  border: 0 !important;
+  border-radius: var(--launcher-radius-card) var(--launcher-radius-card) 0 0 !important;
+  background: transparent !important;
+  box-shadow: none !important;
+  outline: 0 !important;
+  backdrop-filter: none !important;
+  -webkit-backdrop-filter: none !important;
+}
+
+.seo-launcher-shell.project-open .topbar::after {
+  display: none !important;
+}
+
+.seo-launcher-shell.project-open .topbar > div:first-child {
+  visibility: visible !important;
+  pointer-events: auto !important;
+}
+
+.seo-work-panel-heading {
+  display: grid;
+  min-width: 0;
+  gap: 0.18rem;
+}
+
+.seo-work-panel-heading h2 {
+  margin: 0 !important;
+  color: rgba(8, 8, 10, 0.96) !important;
+  font-size: 1.04rem !important;
+  font-weight: 850 !important;
+  letter-spacing: 0 !important;
+  line-height: 1.06 !important;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.seo-work-panel-heading p {
+  margin: 0 !important;
+  color: rgba(8, 8, 10, 0.56) !important;
+  font-size: 0.78rem !important;
+  font-weight: 620 !important;
+  line-height: 1.16 !important;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.seo-work-panel-toolbar {
+  display: flex;
+  min-width: 0;
+  align-items: center;
+  justify-content: flex-end;
+  gap: 0.6rem;
+}
+
+.seo-topbar-primary-action {
+  display: inline-flex;
+  min-height: 2.65rem;
+  align-items: center;
+  justify-content: center;
+  gap: 0.45rem;
+  padding: 0 1.15rem;
+  border: 0;
+  border-radius: 999px;
+  background: rgba(24, 24, 24, 0.94);
+  color: #fff;
+  font-size: 0.86rem;
+  font-weight: 820;
+  white-space: nowrap;
+}
+
+.seo-topbar-primary-action:disabled {
+  cursor: not-allowed;
+  background: rgba(10, 12, 14, 0.12);
+  color: rgba(10, 12, 14, 0.42);
+}
+
+.seo-topbar-workspace-actions {
+  display: inline-flex;
+  min-width: 0;
+  align-items: center;
+  gap: 0.42rem;
+}
+
+.seo-topbar-workspace-actions > button,
+.seo-topbar-preview-mode-switch > button {
+  display: inline-flex;
+  min-height: 2.34rem;
+  align-items: center;
+  justify-content: center;
+  gap: 0.38rem;
+  padding: 0 0.86rem;
+  border: 0;
+  border-radius: 999px;
+  background: rgba(10, 12, 14, 0.06);
+  color: rgba(8, 8, 10, 0.58);
+  font-size: 0.8rem;
+  font-weight: 800;
+  letter-spacing: 0;
+  white-space: nowrap;
+}
+
+.seo-topbar-workspace-actions > button.active,
+.seo-topbar-preview-mode-switch > button.active {
+  background: rgba(24, 24, 24, 0.94);
+  color: #fff;
+}
+
+.seo-topbar-workspace-actions em {
+  display: inline-flex;
+  min-width: 1.34rem;
+  min-height: 1.34rem;
+  align-items: center;
+  justify-content: center;
+  padding: 0 0.32rem;
+  border-radius: 999px;
+  background: rgba(255, 255, 255, 0.72);
+  color: rgba(8, 8, 10, 0.68);
+  font-style: normal;
+  line-height: 1;
+}
+
+.seo-topbar-workspace-actions > button.active em {
+  background: rgba(255, 255, 255, 0.2);
+  color: #fff;
+}
+
+.seo-topbar-preview-mode-switch {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.12rem;
+  min-height: 2.5rem;
+  padding: 0.18rem;
+  border-radius: 999px;
+  background: rgba(255, 255, 255, 0.56);
+}
+
+.seo-launcher-shell.project-open .seo-work-panel {
+  background:
+    linear-gradient(180deg, rgba(255, 255, 255, 0.82), rgba(255, 255, 255, 0.66)),
+    rgba(255, 255, 255, 0.76) !important;
+}
+
+.seo-launcher-shell .workspace.stage-2 .project-scope-flow-controls {
+  justify-content: flex-end !important;
+}
+
+.seo-launcher-shell .workspace.stage-2 .project-scope-flow-confirm-copy {
+  max-width: min(38rem, calc(100% - 11rem));
+  text-align: right;
+}
+
+/* Stage 3: clean preview-first workspace, no secondary document chrome. */
+.seo-launcher-shell .workspace.stage-3 .project-setup {
+  display: grid !important;
+  height: 100% !important;
+  min-height: 0 !important;
+  grid-template-rows: minmax(0, 1fr);
+  overflow: hidden !important;
+  padding: 0 1rem 1rem !important;
+}
+
+.seo-launcher-shell .workspace.stage-3 .project-grid,
+.seo-launcher-shell .workspace.stage-3 .project-list-card,
+.seo-launcher-shell .workspace.stage-3 .project-list,
+.seo-launcher-shell .workspace.stage-3 .project-row,
+.seo-launcher-shell .workspace.stage-3 .project-row > div:first-child,
+.seo-launcher-shell .workspace.stage-3 .scan-summary,
+.seo-launcher-shell .workspace.stage-3 .scan-selection,
+.seo-launcher-shell .workspace.stage-3 .page-workspace-panel,
+.seo-launcher-shell .workspace.stage-3 .workspace-editor-stack,
+.seo-launcher-shell .workspace.stage-3 .workspace-preview-panel,
+.seo-launcher-shell .workspace.stage-3 .workspace-preview-shell {
+  display: grid !important;
+  height: 100% !important;
+  min-height: 0 !important;
+  overflow: hidden !important;
+}
+
+.seo-launcher-shell .workspace.stage-3 .project-grid,
+.seo-launcher-shell .workspace.stage-3 .project-list-card,
+.seo-launcher-shell .workspace.stage-3 .project-list,
+.seo-launcher-shell .workspace.stage-3 .project-row,
+.seo-launcher-shell .workspace.stage-3 .project-row > div:first-child,
+.seo-launcher-shell .workspace.stage-3 .scan-summary,
+.seo-launcher-shell .workspace.stage-3 .scan-selection,
+.seo-launcher-shell .workspace.stage-3 .page-workspace-panel {
+  grid-template-rows: minmax(0, 1fr);
+}
+
+.seo-launcher-shell .workspace.stage-3 .project-row {
+  grid-template-rows: minmax(0, 1fr) !important;
+}
+
+.seo-launcher-shell .workspace.stage-3 .project-row > div:first-child {
+  grid-row: 1 / -1 !important;
+  height: 100% !important;
+}
+
+.seo-launcher-shell .workspace.stage-3 .project-row > :not(div:first-child) {
+  display: none !important;
+}
+
+.seo-launcher-shell .workspace.stage-3 .scan-selection {
+  padding: 0 !important;
+}
+
+.seo-launcher-shell .workspace.stage-3 .workspace-editor-stack {
+  grid-template-rows: minmax(0, 1fr) !important;
+  gap: 0 !important;
+}
+
+.seo-launcher-shell .workspace.stage-3 .workspace-current-page {
+  display: none !important;
+  padding: 0 !important;
+}
+
+.seo-launcher-shell .workspace.stage-3 .workspace-current-page > div {
+  gap: 0.18rem !important;
+}
+
+.seo-launcher-shell .workspace.stage-3 .workspace-current-page small {
+  color: rgba(10, 12, 14, 0.56) !important;
+  font-size: 0.78rem !important;
+  font-weight: 620 !important;
+  line-height: 1.16 !important;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.seo-launcher-shell .workspace.stage-3 .workspace-current-page strong {
+  color: rgba(8, 8, 10, 0.96) !important;
+  font-size: clamp(1.12rem, 1.35vw, 1.52rem) !important;
+  font-weight: 820 !important;
+  letter-spacing: 0 !important;
+  line-height: 1.08 !important;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.seo-launcher-shell .workspace.stage-3 .workspace-cockpit-toolbar,
+.seo-launcher-shell .workspace.stage-3 .workspace-preview-status,
+.seo-launcher-shell .workspace.stage-3 .workspace-current-page-actions,
+.seo-launcher-shell .workspace.stage-3 .workspace-raw-draft {
+  display: none !important;
+}
+
+.seo-launcher-shell .workspace.stage-3 .workspace-preview-panel {
+  gap: 0 !important;
+  padding: 0 !important;
+  border: 1px solid rgba(31, 42, 37, 0.1) !important;
+  border-radius: 1rem !important;
+  background: #ffffff !important;
+}
+
+.seo-launcher-shell .workspace.stage-3 .workspace-preview-shell {
+  min-height: 0 !important;
+  border: 0 !important;
+  border-radius: 1rem !important;
+}
+
+.seo-launcher-shell .workspace.stage-3 .workspace-preview-frame {
+  height: 100% !important;
+  min-height: 0 !important;
+  overflow: auto !important;
+  border: 0 !important;
+  border-radius: 0 !important;
+}
+
+.seo-launcher-shell .workspace.stage-3 .workspace-preview-frame iframe {
+  height: 100% !important;
+  min-height: 0 !important;
+  border: 0 !important;
+  border-radius: 0 !important;
+}
+
+.seo-launcher-shell .workspace.stage-3 .workspace-preview-frame.mobile-preview {
+  display: block !important;
+  overflow: auto !important;
+  padding: 0 !important;
+  background: #ffffff !important;
+}
+
+.seo-launcher-shell .workspace.stage-3 .workspace-preview-frame.mobile-preview iframe {
+  width: 100% !important;
+  min-width: 0 !important;
+  height: 100% !important;
+  min-height: 0 !important;
+  border: 0 !important;
+  border-radius: 0 !important;
+  box-shadow: none !important;
+}