From 089bc2406fc98af4ba8e3de182c7c0f3c8f06521 Mon Sep 17 00:00:00 2001
From: DCCONSTRUCTIONS <dcconstructions@MacBook-Pro-DCCONSTRUCTIONS-2.local>
Date: Thu, 23 Jul 2026 13:47:57 +0300
Subject: [PATCH] Generalize semantic block editing across page workspaces

---
 seo_mode/seo_mode/app/src/App.tsx             | 1818 ++++++++++++++---
 seo_mode/seo_mode/app/src/api.ts              |    5 +
 seo_mode/seo_mode/app/src/styles.css          |  421 +++-
 .../seo_mode/server/src/preview/routes.ts     | 1600 +++++++++++++--
 .../server/src/preview/semanticBlockRules.ts  |   19 +-
 .../seo_mode/server/src/projects/routes.ts    |    5 +
 .../server/src/rewrite/rewriteDiff.ts         |   23 +-
 .../scripts/checkSemanticBlockUniversality.ts |  275 ++-
 .../server/src/workspace/pageWorkspace.ts     |  222 +-
 .../server/src/workspace/previewTargets.ts    |  331 ++-
 .../server/src/workspace/semanticBlocks.ts    |   76 +-
 11 files changed, 4229 insertions(+), 566 deletions(-)

diff --git a/seo_mode/seo_mode/app/src/App.tsx b/seo_mode/seo_mode/app/src/App.tsx
index f74aca4..9b797a3 100644
--- a/seo_mode/seo_mode/app/src/App.tsx
+++ b/seo_mode/seo_mode/app/src/App.tsx
@@ -18,6 +18,7 @@ import {
   Loader2,
   Maximize2,
   Minimize2,
+  MousePointer2,
   Pencil,
   Plug,
   Plus,
@@ -7076,6 +7077,7 @@ function getPipelineStageAccess(
     hasProject: boolean;
     keywordMap: KeywordMapContract | null;
     marketEnrichment: MarketEnrichmentContract | null;
+    rewritePlan: RewritePlanContract | null;
     scan: ProjectScanSummary | null | undefined;
     semanticAnalysis: SemanticAnalysisRun | null;
     seoStrategy: SeoStrategyContract | null;
@@ -7088,6 +7090,7 @@ function getPipelineStageAccess(
   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 planReady = strategyReady || Boolean(input.rewritePlan);
   const synthesisReady = strategyReady && input.strategySynthesis?.state === "ready";
   const qualityReady = synthesisReady && input.strategyQualityReview?.state === "ready";
 
@@ -7145,9 +7148,9 @@ function getPipelineStageAccess(
 
   if (stageIndex === 6) {
     return {
-      reason: strategyReady ? "Стратегия посадочных собрана, можно смотреть план правок." : "План правок откроется после формирования стратегии.",
-      status: strategyReady ? "ready" : "locked",
-      unlocked: strategyReady
+      reason: planReady ? "Стратегия посадочных собрана, можно смотреть план правок." : "План правок откроется после формирования стратегии.",
+      status: planReady ? "ready" : "locked",
+      unlocked: planReady
     };
   }
 
@@ -8307,9 +8310,10 @@ function getWorkspaceTargetPreviewNeedles(target: WorkspaceTarget) {
 function buildVisualComposerGroupText(
   groupId: string,
   targets: WorkspaceTarget[],
-  sectionTextMap: WorkspaceSectionTextMap | undefined
+  sectionTextMap: WorkspaceSectionTextMap | undefined,
+  semanticGroupContextTexts: Record<string, string[]> | undefined
 ) {
-  return targets
+  const boundText = targets
     .filter((target) => target.semanticGroup?.id === groupId && target.permission === "editable")
     .sort((left, right) => (left.semanticGroup?.fieldOrder ?? left.number) - (right.semanticGroup?.fieldOrder ?? right.number))
     .map((target) => {
@@ -8319,6 +8323,13 @@ function buildVisualComposerGroupText(
     })
     .filter(Boolean)
     .join("\n");
+  const contextText = (semanticGroupContextTexts?.[groupId] ?? [])
+    .map((value) => value.replace(/\s+/g, " ").trim())
+    .filter(Boolean)
+    .map((value) => `context: ${value}`)
+    .join("\n");
+
+  return [boundText, contextText].filter(Boolean).join("\n");
 }
 
 function buildVisualComposerPageContextText(targets: WorkspaceTarget[], sectionTextMap: WorkspaceSectionTextMap | undefined) {
@@ -8356,7 +8367,8 @@ function buildVisualComposerSeedInputs(
   pageId: string | null,
   pageTitle: string | null,
   targets: WorkspaceTarget[],
-  sectionTextMap: WorkspaceSectionTextMap | undefined
+  sectionTextMap: WorkspaceSectionTextMap | undefined,
+  semanticGroupContextTexts?: Record<string, string[]>
 ): VisualComposerSeedInput[] {
   if (!pageId) {
     return [];
@@ -8382,7 +8394,7 @@ function buildVisualComposerSeedInputs(
             fieldCount: target.semanticGroup.fieldCount,
             fieldOrder: target.semanticGroup.fieldOrder,
             fieldRole: target.semanticGroup.fieldRole,
-            groupText: buildVisualComposerGroupText(target.semanticGroup.id, targets, sectionTextMap),
+            groupText: buildVisualComposerGroupText(target.semanticGroup.id, targets, sectionTextMap, semanticGroupContextTexts),
             id: target.semanticGroup.id,
             source: target.semanticGroup.source,
             title: target.semanticGroup.title
@@ -8921,7 +8933,7 @@ function getSectionWorkspaceScopeItem(
   section: ProjectScanSummary["siteSections"][number],
   fallbackOrder: number
 ): WorkspaceScopeItem | null {
-  if (!section.pageId || !section.enabled || !section.selected) {
+  if (!section.pageId || !section.enabled) {
     return null;
   }
 
@@ -8952,61 +8964,133 @@ function getSectionWorkspaceScopeItem(
   };
 }
 
-function isSafeWorkspaceDomIdFragment(value: string | null | undefined) {
-  return Boolean(value && /^[a-zA-Z][\w:-]*$/.test(value));
-}
-
-function getWorkspaceScopedAnchorFallbackSelector(scopeItem: WorkspaceScopeItem | null | undefined) {
-  if (
-    !scopeItem ||
-    scopeItem.kind !== "section" ||
-    (scopeItem.previewTargetIndex ?? 0) <= 0 ||
-    !scopeItem.sectionId ||
-    !scopeItem.previewTargetSelector?.startsWith("#")
-  ) {
-    return null;
-  }
-
-  const anchorId = scopeItem.previewTargetSelector.slice(1);
-
-  if (!isSafeWorkspaceDomIdFragment(scopeItem.sectionId) || !isSafeWorkspaceDomIdFragment(anchorId)) {
-    return null;
-  }
-
-  return `#${scopeItem.sectionId}-${anchorId}`;
-}
-
 function getWorkspaceScopePreviewFocusSelector(scopeItem: WorkspaceScopeItem | null | undefined) {
-  return getWorkspaceScopedAnchorFallbackSelector(scopeItem) ?? scopeItem?.previewTargetSelector ?? null;
+  return scopeItem?.previewTargetSelector ?? null;
 }
 
 function getWorkspaceScopePreviewFocusIndex(scopeItem: WorkspaceScopeItem | null | undefined) {
-  return getWorkspaceScopedAnchorFallbackSelector(scopeItem) ? 0 : scopeItem?.previewTargetIndex ?? null;
+  return scopeItem?.previewTargetIndex ?? null;
 }
 
 function normalizeWorkspacePreviewSourceKey(value: string | null | undefined) {
   return (value ?? "")
     .replace(/\\/g, "/")
-    .replace(/^\/+/, "")
-    .toLocaleLowerCase("ru-RU");
+    .replace(/^\/+/, "");
 }
 
 function getWorkspaceScopePreviewSourceKey(scopeItem: WorkspaceScopeItem | null | undefined) {
   return normalizeWorkspacePreviewSourceKey(scopeItem?.previewSourcePath ?? scopeItem?.sourcePath);
 }
 
+type WorkspaceSectionHostRef = {
+  pageId: string | null;
+  previewSourcePath: string | null;
+  sourcePath: string;
+};
+
+function getWorkspaceSectionHostPage(scan: ProjectScanSummary, section: WorkspaceSectionHostRef) {
+  const exactPage = section.pageId
+    ? scan.pages.find(
+        (page) =>
+          page.pageId === section.pageId &&
+          page.scope !== "template_block" &&
+          isWorkspaceScopePage(page)
+      ) ?? null
+    : null;
+
+  if (exactPage) {
+    return exactPage;
+  }
+
+  const previewSourceKey = normalizeWorkspacePreviewSourceKey(section.previewSourcePath ?? section.sourcePath);
+
+  if (!previewSourceKey) {
+    return null;
+  }
+
+  // A source path is only a safe fallback identity when the whole scan has one
+  // logical, non-template page for it. One selected route among several routes
+  // served by the same SPA index is still ambiguous and must not inherit blocks.
+  const logicalHostPages = scan.pages.filter(
+    (page) =>
+      page.scope !== "template_block" &&
+      normalizeWorkspacePreviewSourceKey(page.previewSourcePath ?? page.sourcePath) === previewSourceKey
+  );
+
+  return logicalHostPages.length === 1 && isWorkspaceScopePage(logicalHostPages[0]!)
+    ? logicalHostPages[0]!
+    : null;
+}
+
+function getWorkspaceRenderedPageKey(
+  scopeItem: WorkspaceScopeItem | null | undefined,
+  scopeItems: WorkspaceScopeItem[],
+  scan: ProjectScanSummary
+) {
+  if (!scopeItem) {
+    return "";
+  }
+
+  // Logical pages are distinct render instances even when an SPA serves all
+  // routes from one index.html. Sections may join a page only when the scanner
+  // result has one unambiguous host page for their exact, case-sensitive source.
+  if (scopeItem.kind === "page") {
+    return `page:${scopeItem.pageId}`;
+  }
+
+  const hostPage = getWorkspaceSectionHostPage(scan, scopeItem);
+  const hostScopeItem = hostPage
+    ? scopeItems.find((item) => item.kind === "page" && item.pageId === hostPage.pageId)
+    : null;
+
+  if (hostScopeItem) {
+    return `page:${hostScopeItem.pageId}`;
+  }
+
+  // Ambiguous SPA/template output must remain isolated until the scanner can
+  // provide an opaque render-instance id. Isolation is safer than cross-page
+  // merging and destructive replacement during persistence.
+  return `scope:${scopeItem.scopeId}`;
+}
+
+function normalizeWorkspaceScopeSearchText(value: string | null | undefined) {
+  return (value ?? "")
+    .normalize("NFKC")
+    .toLocaleLowerCase()
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function filterWorkspaceScopeItems(scopeItems: WorkspaceScopeItem[], query: string) {
+  const normalizedQuery = normalizeWorkspaceScopeSearchText(query);
+
+  if (!normalizedQuery) {
+    return scopeItems;
+  }
+
+  return scopeItems.filter((item) =>
+    normalizeWorkspaceScopeSearchText(
+      [item.title, item.pathLabel, item.sourcePath, item.previewSourcePath, ...item.headings].filter(Boolean).join(" ")
+    ).includes(normalizedQuery)
+  );
+}
+
 function getSelectedWorkspaceScopeItems(scan: ProjectScanSummary): WorkspaceScopeItem[] {
+  const eligibleSections = scan.siteSections.filter(
+    (section) =>
+      section.enabled &&
+      Boolean(section.pageId) &&
+      (section.selected || Boolean(getWorkspaceSectionHostPage(scan, section)))
+  );
   const sectionPageIds = new Set(
-    scan.siteSections
-      .filter((section) => section.selected && section.enabled && section.pageId)
-      .map((section) => section.pageId!)
+    eligibleSections.map((section) => section.pageId!)
   );
   const pageItems = scan.pages
     .map((page, index) => ({ index, page }))
     .filter(({ page }) => isWorkspaceScopePage(page))
     .filter(({ page }) => page.scope !== "template_block" || !sectionPageIds.has(page.pageId))
     .map(({ page, index }) => getPageWorkspaceScopeItem(page, index));
-  const sectionItems = scan.siteSections
+  const sectionItems = eligibleSections
     .map((section, index) => getSectionWorkspaceScopeItem(section, index))
     .filter((item): item is WorkspaceScopeItem => Boolean(item));
 
@@ -9204,6 +9288,14 @@ function getWorkspaceScopeIdFromWorkspaceKey(workspaceKey: string) {
   return workspaceKey.split(":").slice(1).join(":");
 }
 
+function omitProjectWorkspaceEntries<T>(record: Record<string, T>, projectId: string) {
+  const workspacePrefix = `${projectId}:`;
+
+  return Object.fromEntries(
+    Object.entries(record).filter(([key]) => key !== projectId && !key.startsWith(workspacePrefix))
+  ) as Record<string, T>;
+}
+
 type WorkspaceSection = PageWorkspace["sections"][number];
 type WorkspaceSectionTextMap = Record<string, string>;
 
@@ -9272,6 +9364,7 @@ const WORKSPACE_PREVIEW_MODES: Array<{ id: WorkspacePreviewMode; label: string }
 
 const SEMANTIC_BLOCK_EDITOR_ENABLED = true;
 const SEMANTIC_BLOCK_OVERRIDES_ENABLED = true;
+const SEMANTIC_BLOCK_EDITOR_MODEL = "semantic_membership.v2";
 
 type PreviewMarker = {
   targetId: string;
@@ -9288,6 +9381,7 @@ type WorkspaceSemanticBlockOverride = {
   capturedEntities?: WorkspaceSemanticBlockCapturedEntity[];
   geometry?: WorkspaceSemanticBlockGeometry;
   id: string;
+  identity?: Record<string, unknown>;
   title: string;
   targetIds: string[];
 };
@@ -9299,6 +9393,42 @@ type WorkspaceSemanticBlockDraftBox = WorkspaceSemanticBlockOverride & {
   width?: number;
 };
 
+function markStage7SemanticMembership<T extends WorkspaceSemanticBlockOverride | WorkspaceSemanticBlockDraftBox>(box: T): T {
+  return {
+    ...box,
+    identity: {
+      ...(box.identity ?? {}),
+      editorModel: SEMANTIC_BLOCK_EDITOR_MODEL,
+      membershipAuthority: "explicit_members"
+    }
+  };
+}
+
+function isStage7SemanticMembership(box: WorkspaceSemanticBlockOverride | WorkspaceSemanticBlockDraftBox) {
+  return box.identity?.editorModel === SEMANTIC_BLOCK_EDITOR_MODEL || box.identity?.membershipAuthority === "explicit_members";
+}
+
+type WorkspaceTextInspectorSelection = {
+  characterCount: number;
+  childElementCount: number;
+  draftApplied: boolean;
+  editable: boolean;
+  id: string;
+  keywordBindings: Array<{ phrase?: string; role?: string }>;
+  previewPatchSafe: boolean;
+  rect: { height: number; left: number; top: number; width: number };
+  role: string;
+  sectionId: string;
+  selector: string;
+  selectorIndex: number;
+  semanticBlockId: string;
+  tagName: string;
+  targetId: string;
+  targetSource: string;
+  targetTitle: string;
+  text: string;
+};
+
 type WorkspaceSemanticBlockAnchor = {
   entityType: string;
   fingerprint?: {
@@ -9317,9 +9447,73 @@ type WorkspaceSemanticBlockAnchor = {
   text?: string;
 };
 
+function sanitizeWorkspaceTextInspectorSelection(value: unknown): WorkspaceTextInspectorSelection | null {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+
+  const record = value as Record<string, unknown>;
+  const id = typeof record.id === "string" ? record.id.trim() : "";
+  const selector = typeof record.selector === "string" ? record.selector.trim() : "";
+  const text = typeof record.text === "string" ? record.text.trim().slice(0, 4000) : "";
+  const rectRecord = record.rect && typeof record.rect === "object" && !Array.isArray(record.rect)
+    ? record.rect as Record<string, unknown>
+    : null;
+
+  if (
+    !id ||
+    !selector ||
+    !text ||
+    typeof rectRecord?.left !== "number" ||
+    typeof rectRecord?.top !== "number" ||
+    typeof rectRecord?.width !== "number" ||
+    typeof rectRecord?.height !== "number"
+  ) {
+    return null;
+  }
+
+  const keywordBindings = Array.isArray(record.keywordBindings)
+    ? record.keywordBindings.flatMap((binding): Array<{ phrase?: string; role?: string }> => {
+        if (!binding || typeof binding !== "object" || Array.isArray(binding)) return [];
+        const bindingRecord = binding as Record<string, unknown>;
+        const phrase = typeof bindingRecord.phrase === "string" ? bindingRecord.phrase.trim().slice(0, 300) : undefined;
+        const role = typeof bindingRecord.role === "string" ? bindingRecord.role.trim().slice(0, 80) : undefined;
+        return phrase || role ? [{ phrase, role }] : [];
+      }).slice(0, 12)
+    : [];
+
+  return {
+    characterCount: typeof record.characterCount === "number" ? Math.max(0, record.characterCount) : text.length,
+    childElementCount: typeof record.childElementCount === "number" ? Math.max(0, record.childElementCount) : 0,
+    draftApplied: Boolean(record.draftApplied),
+    editable: Boolean(record.editable),
+    id,
+    keywordBindings,
+    previewPatchSafe: Boolean(record.previewPatchSafe),
+    rect: {
+      height: Math.max(0, rectRecord.height),
+      left: Math.max(0, rectRecord.left),
+      top: Math.max(0, rectRecord.top),
+      width: Math.max(0, rectRecord.width)
+    },
+    role: typeof record.role === "string" ? record.role.slice(0, 80) : "text",
+    sectionId: typeof record.sectionId === "string" ? record.sectionId.slice(0, 180) : "",
+    selector,
+    selectorIndex: typeof record.selectorIndex === "number" ? Math.max(0, record.selectorIndex) : 0,
+    semanticBlockId: typeof record.semanticBlockId === "string" ? record.semanticBlockId.slice(0, 180) : "",
+    tagName: typeof record.tagName === "string" ? record.tagName.slice(0, 40) : "text",
+    targetId: typeof record.targetId === "string" ? record.targetId.slice(0, 240) : "",
+    targetSource: typeof record.targetSource === "string" ? record.targetSource.slice(0, 80) : "unbound_dom",
+    targetTitle: typeof record.targetTitle === "string" ? record.targetTitle.slice(0, 300) : "",
+    text
+  };
+}
+
 type WorkspaceSemanticBlockCapturedEntity = {
   id: string;
   kind: string;
+  pageId?: string;
+  scopeId?: string;
   selector: string;
   selectorIndex: number;
   text?: string;
@@ -9336,6 +9530,7 @@ type WorkspaceSemanticBlockGeometry = {
   documentWidth?: number;
   height: number;
   left: number;
+  mode?: "anchor" | "manual";
   offsets?: {
     bottom: number;
     left: number;
@@ -9349,6 +9544,12 @@ type WorkspaceSemanticBlockGeometry = {
 const SEMANTIC_BLOCK_OVERRIDES_STORAGE_KEY = "seo-mode.semanticBlockOverrides.v3";
 const WORKSPACE_UI_CONTEXT_STORAGE_KEY = "seo-mode.workspaceUiContext.v1";
 
+function sanitizeSemanticBlockIdentity(value: unknown): Record<string, unknown> | undefined {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? { ...(value as Record<string, unknown>) }
+    : undefined;
+}
+
 function sanitizeSemanticBlockCapturedEntities(value: unknown): WorkspaceSemanticBlockCapturedEntity[] {
   if (!Array.isArray(value)) {
     return [];
@@ -9370,6 +9571,8 @@ function sanitizeSemanticBlockCapturedEntities(value: unknown): WorkspaceSemanti
       {
         id: typeof record.id === "string" && record.id.trim() ? record.id.trim() : selector,
         kind: typeof record.kind === "string" && record.kind.trim() ? record.kind.trim() : "element",
+        pageId: typeof record.pageId === "string" && record.pageId.trim() ? record.pageId.trim() : undefined,
+        scopeId: typeof record.scopeId === "string" && record.scopeId.trim() ? record.scopeId.trim() : undefined,
         selector,
         selectorIndex: typeof record.selectorIndex === "number" && Number.isFinite(record.selectorIndex) ? Math.max(0, record.selectorIndex) : 0,
         text: typeof record.text === "string" && record.text.trim() ? record.text.trim().slice(0, 500) : undefined
@@ -9462,6 +9665,8 @@ function getAnchorsFromCapturedEntities(entities: WorkspaceSemanticBlockCaptured
       text: entity.text
     },
     id: `captured:${entity.selector}:${entity.selectorIndex}`,
+    pageId: entity.pageId,
+    scopeId: entity.scopeId,
     selector: entity.selector,
     selectorIndex: entity.selectorIndex,
     source: "captured_dom",
@@ -9517,6 +9722,7 @@ function sanitizeSemanticBlockGeometry(value: unknown): WorkspaceSemanticBlockGe
     documentWidth: typeof record.documentWidth === "number" && Number.isFinite(record.documentWidth) ? record.documentWidth : undefined,
     height: Math.max(2, height),
     left: Math.max(0, left),
+    mode: record.mode === "manual" ? "manual" : record.mode === "anchor" ? "anchor" : undefined,
     offsets,
     top: Math.max(0, top),
     width: Math.max(2, width)
@@ -9544,6 +9750,7 @@ function getMergedSemanticBlockGeometry(
     documentWidth: Math.max(current.documentWidth ?? 0, next.documentWidth ?? 0) || (current.documentWidth ?? next.documentWidth),
     height: Math.max(2, bottom - top),
     left,
+    mode: current.mode === "manual" || next.mode === "manual" ? "manual" : current.mode ?? next.mode,
     top,
     width: Math.max(2, right - left)
   };
@@ -9564,21 +9771,17 @@ function collapseCarouselVisualSemanticBlockOverrides(overrides: WorkspaceSemant
     const visualMatch = /^(.*):visual-\d+$/i.exec(override.id);
     const titleMatch = /^(.*?)(?:\s+|[-_#])\d+$/i.exec(override.title);
     const baseTitle = (titleMatch?.[1] ?? override.title).trim();
-    const hasGeometry = Boolean(override.geometry);
-    const baseId =
-      visualMatch?.[1] ??
-      (titleMatch && hasGeometry && CAROUSEL_LIKE_SEMANTIC_PATTERN.test(baseTitle.toLocaleLowerCase("ru-RU"))
-        ? `manual-carousel:${normalizeSemanticBlockIdFragment(baseTitle).toLocaleLowerCase("ru-RU")}`
-        : "");
+    const baseId = visualMatch?.[1] ?? "";
     const searchableValue = `${baseId} ${baseTitle} ${override.title}`.toLocaleLowerCase("ru-RU");
 
+    // A stable :visual-N id may represent several projections of one entity.
+    // Geometry/title similarity alone must never create semantic membership.
     if (!baseId || !CAROUSEL_LIKE_SEMANTIC_PATTERN.test(searchableValue)) {
       result.push(override);
       return;
     }
 
-    const band = Math.round((override.geometry?.top ?? 0) / Math.max(220, override.geometry?.height ?? 220));
-    const mergeKey = baseId.startsWith("manual-carousel:") ? `${baseId}:band-${band}` : baseId;
+    const mergeKey = baseId;
     const current = merged.get(mergeKey);
 
     if (!current) {
@@ -9596,11 +9799,36 @@ function collapseCarouselVisualSemanticBlockOverrides(overrides: WorkspaceSemant
     current.anchors = mergeSemanticBlockAnchors(current.anchors, override.anchors);
     current.capturedEntities = sanitizeSemanticBlockCapturedEntities([...(current.capturedEntities ?? []), ...(override.capturedEntities ?? [])]);
     current.geometry = getMergedSemanticBlockGeometry(current.geometry, override.geometry);
+    current.identity = {
+      ...(override.identity ?? {}),
+      ...(current.identity ?? {})
+    };
   });
 
   return result;
 }
 
+function mergeSemanticBlockOverrideMembership(
+  current: WorkspaceSemanticBlockOverride | WorkspaceSemanticBlockDraftBox,
+  next: WorkspaceSemanticBlockOverride | WorkspaceSemanticBlockDraftBox
+): WorkspaceSemanticBlockOverride {
+  return {
+    anchors: mergeSemanticBlockAnchors(current.anchors, next.anchors),
+    capturedEntities: sanitizeSemanticBlockCapturedEntities([
+      ...(current.capturedEntities ?? []),
+      ...(next.capturedEntities ?? [])
+    ]),
+    geometry: getMergedSemanticBlockGeometry(current.geometry, next.geometry),
+    id: current.id,
+    identity: {
+      ...(next.identity ?? {}),
+      ...(current.identity ?? {})
+    },
+    targetIds: Array.from(new Set([...current.targetIds, ...next.targetIds])),
+    title: current.title || next.title
+  };
+}
+
 function sanitizeStoredWorkspaceSemanticBlockOverrides(value: unknown): Record<string, WorkspaceSemanticBlockOverride[]> {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return {};
@@ -9628,9 +9856,10 @@ function sanitizeStoredWorkspaceSemanticBlockOverrides(value: unknown): Record<s
         ...getAnchorsFromCapturedEntities(capturedEntities)
       ]);
       const geometry = sanitizeSemanticBlockGeometry(record.geometry);
+      const identity = sanitizeSemanticBlockIdentity(record.identity);
 
       return id && (targetIds.length > 0 || capturedEntities.length > 0 || anchors.length > 0)
-        ? [{ anchors, capturedEntities, geometry, id, targetIds, title }]
+        ? [{ anchors, capturedEntities, geometry, id, identity, targetIds, title }]
         : [];
     });
 
@@ -9676,6 +9905,7 @@ function sanitizeSemanticBlockDraftBoxes(value: unknown): WorkspaceSemanticBlock
       ...getAnchorsFromCapturedEntities(capturedEntities)
     ]);
     const geometry = sanitizeSemanticBlockGeometry(record.geometry);
+    const identity = sanitizeSemanticBlockIdentity(record.identity);
 
     if (!id) {
       return [];
@@ -9688,6 +9918,7 @@ function sanitizeSemanticBlockDraftBoxes(value: unknown): WorkspaceSemanticBlock
         geometry,
         height: typeof record.height === "number" ? record.height : undefined,
         id,
+        identity,
         left: typeof record.left === "number" ? record.left : undefined,
         targetIds,
         title,
@@ -9721,6 +9952,7 @@ function commitSemanticBlockDraftBoxes(boxes: WorkspaceSemanticBlockDraftBox[] |
             capturedEntities,
             geometry,
             id: box.id,
+            identity: sanitizeSemanticBlockIdentity(box.identity),
             targetIds,
             title: box.title
           }
@@ -9740,7 +9972,25 @@ function getSemanticBlockOverridesFromModels(
       return [];
     }
 
-    const capturedEntities = sanitizeSemanticBlockCapturedEntities(block.capturedEntities);
+    const capturedEntities = sanitizeSemanticBlockCapturedEntities([
+      ...block.capturedEntities,
+      ...block.sourceBindings.flatMap((binding) => {
+        if (!binding || typeof binding !== "object" || Array.isArray(binding)) return [];
+        const record = binding as Record<string, unknown>;
+        const selector = typeof record.selector === "string" ? record.selector : "";
+        if (!selector || (record.contextOnly !== true && record.source !== "captured_dom")) return [];
+
+        return [{
+          id: typeof record.id === "string" ? record.id : `binding:${selector}:${Number(record.selectorIndex) || 0}`,
+          kind: typeof record.kind === "string" ? record.kind : "text",
+          pageId: typeof record.sourcePageId === "string" ? record.sourcePageId : undefined,
+          scopeId: typeof record.sourceScopeId === "string" ? record.sourceScopeId : undefined,
+          selector,
+          selectorIndex: typeof record.selectorIndex === "number" ? record.selectorIndex : 0,
+          text: typeof record.textSnapshot === "string" ? record.textSnapshot : undefined
+        }];
+      })
+    ]);
     const anchors = sanitizeSemanticBlockAnchors([
       ...block.anchors,
       ...getAnchorsFromCapturedEntities(capturedEntities)
@@ -9752,13 +10002,14 @@ function getSemanticBlockOverridesFromModels(
       .filter((targetId): targetId is string => Boolean(targetId));
     const targetIds = Array.from(new Set([...block.targetIds.filter(Boolean), ...anchorTargetIds]));
 
-    return blockKey && targetIds.length > 0
+    return blockKey && (targetIds.length > 0 || capturedEntities.length > 0 || anchors.length > 0 || block.sourceBindings.length > 0)
       ? [
           {
             anchors,
             capturedEntities,
             geometry,
             id: blockKey,
+            identity: sanitizeSemanticBlockIdentity(block.identity),
             targetIds,
             title: block.title || "Semantic block"
           }
@@ -9769,48 +10020,133 @@ function getSemanticBlockOverridesFromModels(
   return collapseCarouselVisualSemanticBlockOverrides(overrides);
 }
 
-function buildSemanticBlockSourceBindings(override: WorkspaceSemanticBlockOverride, targets: WorkspaceTarget[]) {
-  const targetsById = new Map(targets.map((target) => [target.id, target]));
-  const anchorTargetIds = sanitizeSemanticBlockAnchors(override.anchors)
+type SemanticBlockBindingTarget = WorkspaceTarget & {
+  semanticSourcePageId?: string;
+  semanticSourceScopeId?: string;
+  semanticSourceWorkspaceKey?: string;
+};
+
+function getSemanticBlockResolvedTargets(
+  override: WorkspaceSemanticBlockOverride,
+  targets: SemanticBlockBindingTarget[]
+) {
+  const targetsById = targets.reduce<Map<string, SemanticBlockBindingTarget[]>>((index, target) => {
+    const candidates = index.get(target.id) ?? [];
+    candidates.push(target);
+    index.set(target.id, candidates);
+    return index;
+  }, new Map());
+  const anchors = sanitizeSemanticBlockAnchors(override.anchors);
+  const anchorTargetIds = anchors
     .map((anchor) => anchor.targetId)
     .filter((targetId): targetId is string => Boolean(targetId));
   const targetIds = Array.from(new Set([...override.targetIds, ...anchorTargetIds]));
 
   return targetIds.flatMap((targetId) => {
-    const target = targetsById.get(targetId);
+    const candidates = targetsById.get(targetId) ?? [];
 
-    if (!target) {
+    if (candidates.length === 0) {
       return [];
     }
 
-    return [
-      {
-        contentField: target.contentField ?? null,
-        fallbackSelector: target.fallbackSelector,
-        kind: target.kind,
-        markerSelectors: target.markerSelectors,
-        permission: target.permission,
-        sectionId: target.sectionId,
-        selector: target.selector,
-        semanticGroup: target.semanticGroup
-          ? {
-              fieldCount: target.semanticGroup.fieldCount,
-              fieldOrder: target.semanticGroup.fieldOrder,
-              fieldRole: target.semanticGroup.fieldRole,
-              id: target.semanticGroup.id,
-              source: target.semanticGroup.source,
-              title: target.semanticGroup.title
-            }
-          : null,
-        source: target.source,
-        subtitle: target.subtitle,
-        targetId,
-        title: target.title
+    const identityAnchors = anchors.filter(
+      (anchor) => anchor.targetId === targetId && Boolean(anchor.scopeId || anchor.pageId)
+    );
+    const anchoredCandidates = new Set<SemanticBlockBindingTarget>();
+
+    identityAnchors.forEach((anchor) => {
+      const matches = candidates.filter(
+        (candidate) =>
+          (!anchor.scopeId || candidate.semanticSourceScopeId === anchor.scopeId) &&
+          (!anchor.pageId || candidate.semanticSourcePageId === anchor.pageId)
+      );
+
+      if (matches.length === 1) {
+        anchoredCandidates.add(matches[0]!);
       }
-    ];
+    });
+
+    if (anchoredCandidates.size > 0) {
+      return Array.from(anchoredCandidates);
+    }
+
+    // A stale explicit identity must not fall through to another scope. Plain
+    // legacy target ids remain usable only when they have one possible owner.
+    return identityAnchors.length === 0 && candidates.length === 1 ? candidates : [];
   });
 }
 
+function buildSemanticBlockSourceBindings(override: WorkspaceSemanticBlockOverride, targets: SemanticBlockBindingTarget[]) {
+  const boundBindings = getSemanticBlockResolvedTargets(override, targets).map((target) => ({
+    contentField: target.contentField ?? null,
+    fallbackSelector: target.fallbackSelector,
+    kind: target.kind,
+    markerSelectors: target.markerSelectors,
+    permission: target.permission,
+    sectionId: target.sectionId,
+    selector: target.selector,
+    sourcePageId: target.semanticSourcePageId ?? null,
+    sourceScopeId: target.semanticSourceScopeId ?? null,
+    sourceWorkspaceKey: target.semanticSourceWorkspaceKey ?? null,
+    semanticGroup: target.semanticGroup
+      ? {
+          fieldCount: target.semanticGroup.fieldCount,
+          fieldOrder: target.semanticGroup.fieldOrder,
+          fieldRole: target.semanticGroup.fieldRole,
+          id: target.semanticGroup.id,
+          source: target.semanticGroup.source,
+          title: target.semanticGroup.title
+        }
+      : null,
+    source: target.source,
+    subtitle: target.subtitle,
+    targetId: target.id,
+    title: target.title
+  }));
+  const boundSelectors = new Set(
+    boundBindings.flatMap((binding) => [binding.selector, ...binding.markerSelectors]).filter(Boolean)
+  );
+  const boundTargetIds = new Set(boundBindings.map((binding) => binding.targetId));
+  const referencedBindings = sanitizeSemanticBlockAnchors(override.anchors)
+    .filter((anchor) => Boolean(anchor.targetId && !boundTargetIds.has(anchor.targetId)))
+    .map((anchor) => ({
+      contextOnly: true,
+      kind: anchor.entityType,
+      permission: "read_only" as const,
+      sectionId: null,
+      selector: anchor.selector ?? null,
+      selectorIndex: anchor.selectorIndex ?? 0,
+      source: "workspace_target_reference" as const,
+      sourcePageId: anchor.pageId ?? null,
+      sourceScopeId: anchor.scopeId ?? null,
+      targetId: anchor.targetId ?? null,
+      textSnapshot: anchor.text ?? anchor.fingerprint?.text ?? "",
+      title: anchor.text?.slice(0, 120) || anchor.targetId || "Workspace target member"
+    }));
+  const reservedSelectors = new Set([
+    ...boundSelectors,
+    ...referencedBindings.map((binding) => binding.selector).filter((value): value is string => Boolean(value))
+  ]);
+  const capturedBindings = sanitizeSemanticBlockCapturedEntities(override.capturedEntities)
+    .filter((entity) => !reservedSelectors.has(entity.selector))
+    .map((entity) => ({
+      contextOnly: true,
+      kind: entity.kind,
+      permission: "read_only" as const,
+      sectionId: null,
+      selector: entity.selector,
+      selectorIndex: entity.selectorIndex,
+      source: "captured_dom" as const,
+      sourcePageId: entity.pageId ?? null,
+      sourceScopeId: entity.scopeId ?? null,
+      targetId: null,
+      textSnapshot: entity.text ?? "",
+      title: entity.text?.slice(0, 120) || "DOM text member"
+    }));
+
+  return [...boundBindings, ...referencedBindings, ...capturedBindings];
+}
+
 function buildSemanticBlockIdentity(override: WorkspaceSemanticBlockOverride, sourceBindings: unknown[]) {
   const bindingRecords = sourceBindings.filter(
     (binding): binding is Record<string, unknown> => Boolean(binding) && typeof binding === "object" && !Array.isArray(binding)
@@ -9829,11 +10165,27 @@ function buildSemanticBlockIdentity(override: WorkspaceSemanticBlockOverride, so
   const anchorKeys = sanitizeSemanticBlockAnchors(override.anchors).map((anchor) =>
     [anchor.source, anchor.targetId ?? "", anchor.selector ?? "", anchor.selectorIndex ?? 0, anchor.scopeId ?? "", anchor.pageId ?? ""].join("::")
   );
+  const sectionRefs = bindingRecords
+    .map((binding) => binding.sectionId)
+    .filter((value): value is string => typeof value === "string" && value.length > 0)
+    .map((sourceSectionId) => ({ entityId: "seo.section", sourceSectionId }));
+  const memberPageIds = Array.from(new Set([
+    ...sanitizeSemanticBlockAnchors(override.anchors).map((anchor) => anchor.pageId),
+    ...sanitizeSemanticBlockCapturedEntities(override.capturedEntities).map((entity) => entity.pageId),
+    ...bindingRecords.map((binding) => binding.sourcePageId)
+  ].filter((value): value is string => typeof value === "string" && value.length > 0)));
 
   return {
+    ...(sanitizeSemanticBlockIdentity(override.identity) ?? {}),
     anchorKeys,
     blockKey: override.id,
     contentFieldPaths: Array.from(new Set(contentFieldPaths)),
+    editorModel: SEMANTIC_BLOCK_EDITOR_MODEL,
+    membershipAuthority: "explicit_members",
+    ontologyEntityId: "seo.semantic_block",
+    ontologyRelationId: "seo.semantic_block.groups_section",
+    memberPageIds,
+    sectionRefs,
     selectors: Array.from(new Set(selectors)),
     targetIds: Array.from(new Set(override.targetIds)),
     title: override.title
@@ -10106,6 +10458,10 @@ function isSafeVisualComposerFallbackSection(section: WorkspaceSection) {
     return false;
   }
 
+  if (["<header>", "<footer>", "<nav>", "<aside>", "<main>"].includes(section.sourceHint)) {
+    return false;
+  }
+
   if (section.kind === "meta") {
     return normalizedText.length <= 240;
   }
@@ -10280,7 +10636,10 @@ function buildWorkspaceSectionTargets(workspace: PageWorkspace, editable = false
 }
 
 function normalizeSemanticBlockIdFragment(value: string) {
-  return value.replace(/[^a-zA-Z0-9а-яА-ЯёЁ._-]+/g, "-").replace(/^-+|-+$/g, "");
+  return value
+    .normalize("NFKC")
+    .replace(/[^\p{L}\p{N}._-]+/gu, "-")
+    .replace(/^-+|-+$/g, "");
 }
 
 const CAROUSEL_LIKE_SEMANTIC_PATTERN =
@@ -10748,10 +11107,14 @@ function buildWorkspaceTargets(
   const visibleAuditTargets = options.includeRewriteTargets
     ? auditTargets.filter((target) => !rewriteSectionIds.has(target.sectionId))
     : auditTargets;
-	  const sectionTargets =
-	    options.includeSectionFallback && rewriteTargets.length === 0 && contentFieldTargets.length === 0
-	      ? buildWorkspaceSectionTargets(workspace, Boolean(options.includeRewriteTargets))
-	      : [];
+  const planBackedSectionIds = new Set(
+    [...rewriteTargets, ...contentFieldTargets].map((target) => target.sectionId).filter(Boolean)
+  );
+  const sectionTargets = options.includeSectionFallback
+    ? buildWorkspaceSectionTargets(workspace, Boolean(options.includeRewriteTargets)).filter(
+        (target) => !planBackedSectionIds.has(target.sectionId)
+      )
+    : [];
 
   return [...rewriteTargets, ...contentFieldTargets, ...visibleAuditTargets, ...sectionTargets].map((target, index) => ({
     ...target,
@@ -10788,12 +11151,7 @@ function getWorkspaceScopeIssues(
       issue.scope === "media" ||
       !["title", "description", "h1", "headings"].includes(issue.field ?? "")
   );
-  const previewSourceKey = getWorkspaceScopePreviewSourceKey(scopeItem);
-  const renderedPage = scan?.pages.find(
-    (page) =>
-      page.scope === "indexable_page" &&
-      normalizeWorkspacePreviewSourceKey(page.previewSourcePath ?? page.sourcePath) === previewSourceKey
-  );
+  const renderedPage = scan ? getWorkspaceSectionHostPage(scan, scopeItem) : null;
   const mediaSignals = scopeItem.editableFields
     .map((field) => normalizeIssueLookupText(field.value))
     .filter((value) => value.length >= 4);
@@ -11108,6 +11466,7 @@ export function App() {
   const folderInputRef = useRef<HTMLInputElement | null>(null);
   const titleInputRef = useRef<HTMLInputElement | null>(null);
   const previewFrameRefs = useRef<Record<string, HTMLIFrameElement | null>>({});
+  const previewBridgeTokensRef = useRef<WeakMap<object, string>>(new WeakMap());
   const semanticExportButtonRef = useRef<HTMLButtonElement | null>(null);
   const semanticExportMenuRef = useRef<HTMLDivElement | null>(null);
   const strategyExportButtonRef = useRef<HTMLButtonElement | null>(null);
@@ -11118,6 +11477,8 @@ export function App() {
   const pendingActiveWorkspaceScopeIdsRef = useRef<Record<string, string>>({});
   const manualWorkspacePreviewScopeLocksRef = useRef<Record<string, { scopeId: string; until: number }>>({});
   const prefetchingWorkspaceKeysRef = useRef(new Set<string>());
+  const pageWorkspaceRequestPromisesRef = useRef(new Map<string, ReturnType<typeof openPageWorkspace>>());
+  const projectWorkspaceGenerationsRef = useRef(new Map<string, number>());
   const [workspaceMode, setWorkspaceMode] = useState<WorkspaceMode>("dev");
   const [activeStageIndex, setActiveStageIndex] = useState(0);
   const [health, setHealth] = useState<HealthResponse | null>(null);
@@ -11253,14 +11614,20 @@ export function App() {
   const [activeWorkspaceTargetIds, setActiveWorkspaceTargetIds] = useState<Record<string, string>>({});
   const [workspacePreviewMarkers, setWorkspacePreviewMarkers] = useState<Record<string, PreviewMarker[]>>({});
   const [workspaceDrawers, setWorkspaceDrawers] = useState<Record<string, WorkspaceDrawerPanel[]>>({});
+  const [workspaceScopeQueries, setWorkspaceScopeQueries] = useState<Record<string, string>>({});
   const [excludedWorkspaceTargetIds, setExcludedWorkspaceTargetIds] = useState<WorkspaceExcludedTargetMap>({});
   const [workspacePreviewScopeIds, setWorkspacePreviewScopeIds] = useState<Record<string, string>>({});
   const [semanticBlockEditModes, setSemanticBlockEditModes] = useState<Record<string, boolean>>({});
   const [semanticBlockEditProjectModes, setSemanticBlockEditProjectModes] = useState<Record<string, boolean>>({});
+  const [workspaceTextInspectorModes, setWorkspaceTextInspectorModes] = useState<Record<string, boolean>>({});
+  const [workspaceTextInspectorSelections, setWorkspaceTextInspectorSelections] = useState<
+    Record<string, WorkspaceTextInspectorSelection>
+  >({});
   const [workspaceSemanticBlockOverrides, setWorkspaceSemanticBlockOverrides] = useState<Record<string, WorkspaceSemanticBlockOverride[]>>(
     () => readStoredWorkspaceSemanticBlockOverrides()
   );
   const [workspaceSemanticBlockDrafts, setWorkspaceSemanticBlockDrafts] = useState<Record<string, WorkspaceSemanticBlockDraftBox[]>>({});
+  const [selectedSemanticBlockIds, setSelectedSemanticBlockIds] = useState<Record<string, string>>({});
   const [semanticBlockGenerationDirty, setSemanticBlockGenerationDirty] = useState<Record<string, boolean>>({});
   const [pageWorkspaces, setPageWorkspaces] = useState<Record<string, PageWorkspace>>({});
   const [workspaceDraftTexts, setWorkspaceDraftTexts] = useState<Record<string, string>>({});
@@ -11268,6 +11635,7 @@ export function App() {
   const [workspaceContentFieldTexts, setWorkspaceContentFieldTexts] = useState<Record<string, WorkspaceSectionTextMap>>({});
   const [workspacePreviewModes, setWorkspacePreviewModes] = useState<Record<string, WorkspacePreviewMode>>({});
   const [busyWorkspaceKey, setBusyWorkspaceKey] = useState<string | null>(null);
+  const [openingProjectId, setOpeningProjectId] = useState<string | null>(null);
   const [projectActionError, setProjectActionError] = useState<string | null>(null);
   const [projectActionMessage, setProjectActionMessage] = useState<string | null>(null);
   const [projectActionProjectId, setProjectActionProjectId] = useState<string | null>(null);
@@ -12084,10 +12452,6 @@ export function App() {
         loadKeywordContextSnapshots,
         loadYandexEvidences,
         loadSerpInterpretations,
-        loadSeoStrategies,
-        loadStrategySyntheses,
-        loadStrategyQualityReviews,
-        loadRewritePlans,
         loadMaterializationContracts,
         loadRewriteDiffContracts,
         loadPatchArtifacts
@@ -12261,7 +12625,8 @@ export function App() {
     workspaceContentFieldTexts,
     workspacePreviewModes,
     workspaceSemanticBlockDrafts,
-    workspaceSemanticBlockOverrides
+    workspaceSemanticBlockOverrides,
+    workspaceTextInspectorModes
 	  ]);
 
 	  useEffect(() => {
@@ -12357,6 +12722,68 @@ export function App() {
         return;
       }
 
+      const messageType = typeof data.type === "string" ? data.type : "";
+      const messageSource = event.source && typeof event.source === "object" ? event.source : null;
+
+      if (messageType === "seo-mode:bridge-ready") {
+        const bridgeSessionToken = typeof data.bridgeSessionToken === "string" ? data.bridgeSessionToken : "";
+
+        if (messageSource && bridgeSessionToken.length >= 16 && bridgeSessionToken.length <= 200) {
+          const currentToken = previewBridgeTokensRef.current.get(messageSource);
+          if (!currentToken) previewBridgeTokensRef.current.set(messageSource, bridgeSessionToken);
+        }
+        return;
+      }
+
+      if (messageType.startsWith("seo-mode:")) {
+        const expectedBridgeToken = messageSource ? previewBridgeTokensRef.current.get(messageSource) : null;
+        if (!expectedBridgeToken || data.bridgeSessionToken !== expectedBridgeToken) return;
+      }
+
+      if (data.type === "seo-mode:text-unit-select") {
+        const workspaceKey = typeof data.workspaceKey === "string" ? data.workspaceKey : "";
+
+        if (!workspaceKey) {
+          return;
+        }
+
+        const expectedFrameWindow = previewFrameRefs.current[workspaceKey]?.contentWindow;
+
+        if (expectedFrameWindow && event.source !== expectedFrameWindow) {
+          return;
+        }
+
+        const selection = sanitizeWorkspaceTextInspectorSelection(data.textUnit);
+        const projectId = getWorkspaceUiKeyFromWorkspaceKey(workspaceKey);
+
+        setWorkspaceTextInspectorSelections((currentSelections) => {
+          if (!selection) {
+            if (!currentSelections[projectId]) return currentSelections;
+            const nextSelections = { ...currentSelections };
+            delete nextSelections[projectId];
+            return nextSelections;
+          }
+
+          return {
+            ...currentSelections,
+            [projectId]: selection
+          };
+        });
+
+        if (selection?.targetId) {
+          setActiveWorkspaceTargetIds((currentTargetIds) => ({
+            ...currentTargetIds,
+            [workspaceKey]: selection.targetId
+          }));
+          setActiveWorkspaceSectionIds((currentSectionIds) => ({
+            ...currentSectionIds,
+            [workspaceKey]: selection.sectionId || selection.targetId
+          }));
+        }
+
+        return;
+      }
+
       if (data.type !== "seo-mode:preview-markers") {
         if (data?.type === "seo-mode:semantic-block-draft") {
           const workspaceKey = typeof data.workspaceKey === "string" ? data.workspaceKey : "";
@@ -12365,19 +12792,31 @@ export function App() {
             return;
           }
 
-          const boxes = sanitizeSemanticBlockDraftBoxes(data.boxes);
+          const expectedFrameWindow = previewFrameRefs.current[workspaceKey]?.contentWindow;
+          if (expectedFrameWindow && event.source !== expectedFrameWindow) {
+            return;
+          }
+
+          const boxes = sanitizeSemanticBlockDraftBoxes(data.boxes).map(markStage7SemanticMembership);
           const hasManualSemanticBlockSet = Boolean(data.hasManualSemanticBlockSet);
+          const selectedBlockId = typeof data.selectedBlockId === "string" ? data.selectedBlockId : "";
+          const ownerWorkspaceKey = getSemanticBlockOwnerWorkspaceKey(workspaceKey);
+
+          setSelectedSemanticBlockIds((currentIds) => ({
+            ...currentIds,
+            [ownerWorkspaceKey]: selectedBlockId
+          }));
 
           setWorkspaceSemanticBlockDrafts((currentDrafts) => {
             if (boxes.length === 0 && !hasManualSemanticBlockSet) {
               const nextDrafts = { ...currentDrafts };
-              delete nextDrafts[workspaceKey];
+              delete nextDrafts[ownerWorkspaceKey];
               return nextDrafts;
             }
 
             return {
               ...currentDrafts,
-              [workspaceKey]: boxes
+              [ownerWorkspaceKey]: boxes
             };
           });
           return;
@@ -12389,43 +12828,49 @@ export function App() {
           if (!workspaceKey || !Array.isArray(data.boxes)) {
             return;
           }
+          const expectedFrameWindow = previewFrameRefs.current[workspaceKey]?.contentWindow;
+          if (expectedFrameWindow && event.source !== expectedFrameWindow) {
+            return;
+          }
           const projectId = getWorkspaceUiKeyFromWorkspaceKey(workspaceKey);
+          const pageWorkspaceKeys = getSemanticBlockPageWorkspaceKeys(workspaceKey);
+          const ownerWorkspaceKey = getSemanticBlockOwnerWorkspaceKey(workspaceKey);
 
-          const currentWorkspaceDraft = sanitizeSemanticBlockDraftBoxes(data.boxes);
-          const projectWorkspacePrefix = `${projectId}:`;
-          const projectDraftEntries = Object.entries(workspaceSemanticBlockDrafts)
-            .filter(([draftWorkspaceKey]) => draftWorkspaceKey.startsWith(projectWorkspacePrefix) && draftWorkspaceKey !== workspaceKey)
-            .map(([draftWorkspaceKey, boxes]) => [draftWorkspaceKey, commitSemanticBlockDraftBoxes(boxes)] as const);
+          const currentWorkspaceDraft = sanitizeSemanticBlockDraftBoxes(data.boxes).map(markStage7SemanticMembership);
           const currentWorkspaceOverrides = commitSemanticBlockDraftBoxes(currentWorkspaceDraft);
+          const clearedWorkspaceOverrides = Object.fromEntries(pageWorkspaceKeys.map((pageWorkspaceKey) => [pageWorkspaceKey, []]));
 
           setWorkspaceSemanticBlockOverrides((existingOverrides) => ({
             ...existingOverrides,
-            ...Object.fromEntries(projectDraftEntries),
-            [workspaceKey]: currentWorkspaceOverrides
+            ...clearedWorkspaceOverrides,
+            [ownerWorkspaceKey]: currentWorkspaceOverrides
           }));
           setSemanticBlockGenerationDirty((currentDirty) => ({
             ...currentDirty,
-            ...Object.fromEntries(projectDraftEntries.map(([draftWorkspaceKey]) => [draftWorkspaceKey, true])),
-            [workspaceKey]: true
+            ...Object.fromEntries(pageWorkspaceKeys.map((pageWorkspaceKey) => [pageWorkspaceKey, pageWorkspaceKey === ownerWorkspaceKey]))
           }));
-	          setWorkspaceSemanticBlockDrafts((currentDrafts) =>
-	            Object.fromEntries(Object.entries(currentDrafts).filter(([draftWorkspaceKey]) => !draftWorkspaceKey.startsWith(projectWorkspacePrefix)))
-	          );
-          void persistWorkspaceSemanticBlocks(workspaceKey, currentWorkspaceOverrides);
-          projectDraftEntries.forEach(([draftWorkspaceKey, draftOverrides]) => {
-            void persistWorkspaceSemanticBlocks(draftWorkspaceKey, draftOverrides);
-          });
+	          setWorkspaceSemanticBlockDrafts((currentDrafts) => {
+              const pageWorkspaceKeySet = new Set(pageWorkspaceKeys);
+              return Object.fromEntries(Object.entries(currentDrafts).filter(([draftWorkspaceKey]) => !pageWorkspaceKeySet.has(draftWorkspaceKey)));
+            });
+          void persistSemanticBlockPage(ownerWorkspaceKey, currentWorkspaceOverrides);
 	          setSemanticBlockEditModes((currentModes) => ({
 	            ...currentModes,
-	            [workspaceKey]: false
+	            ...Object.fromEntries(pageWorkspaceKeys.map((pageWorkspaceKey) => [pageWorkspaceKey, false]))
           }));
           setSemanticBlockEditProjectModes((currentModes) => ({
             ...currentModes,
             [projectId]: false
           }));
+          setSelectedSemanticBlockIds((currentIds) => {
+            if (!currentIds[ownerWorkspaceKey]) return currentIds;
+            const nextIds = { ...currentIds };
+            delete nextIds[ownerWorkspaceKey];
+            return nextIds;
+          });
           setProjectActionError(null);
           setProjectActionMessage(
-            `Семантические блоки обновлены: ${currentWorkspaceOverrides.length + projectDraftEntries.reduce((sum, [, boxes]) => sum + boxes.length, 0)}. Нужна новая генерация.`
+            `Семантические блоки страницы обновлены: ${currentWorkspaceOverrides.length}. Нужна новая генерация.`
           );
           setProjectActionProjectId(projectId);
           return;
@@ -13039,6 +13484,61 @@ export function App() {
     }
   }
 
+  function getProjectWorkspaceGeneration(projectId: string) {
+    return projectWorkspaceGenerationsRef.current.get(projectId) ?? 0;
+  }
+
+  function invalidateProjectWorkspaceCaches(projectId: string) {
+    const workspacePrefix = `${projectId}:`;
+    const nextGeneration = getProjectWorkspaceGeneration(projectId) + 1;
+    projectWorkspaceGenerationsRef.current.set(projectId, nextGeneration);
+
+    delete pendingActiveWorkspaceScopeIdsRef.current[projectId];
+    delete manualWorkspacePreviewScopeLocksRef.current[projectId];
+    Array.from(prefetchingWorkspaceKeysRef.current).forEach((key) => {
+      if (key.startsWith(workspacePrefix)) prefetchingWorkspaceKeysRef.current.delete(key);
+    });
+    Array.from(pageWorkspaceRequestPromisesRef.current.keys()).forEach((key) => {
+      if (key.startsWith(workspacePrefix)) pageWorkspaceRequestPromisesRef.current.delete(key);
+    });
+    Object.keys(previewFrameRefs.current).forEach((key) => {
+      if (!key.startsWith(workspacePrefix)) return;
+      const contentWindow = previewFrameRefs.current[key]?.contentWindow;
+      if (contentWindow) previewBridgeTokensRef.current.delete(contentWindow);
+      delete previewFrameRefs.current[key];
+    });
+
+    setActiveWorkspaceScopeIds((current) => omitProjectWorkspaceEntries(current, projectId));
+    setActiveWorkspaceSectionIds((current) => omitProjectWorkspaceEntries(current, projectId));
+    setActiveWorkspaceTargetIds((current) => omitProjectWorkspaceEntries(current, projectId));
+    setWorkspacePreviewMarkers((current) => omitProjectWorkspaceEntries(current, projectId));
+    setWorkspaceDrawers((current) => omitProjectWorkspaceEntries(current, projectId));
+    setWorkspaceScopeQueries((current) => omitProjectWorkspaceEntries(current, projectId));
+    setExcludedWorkspaceTargetIds((current) => omitProjectWorkspaceEntries(current, projectId));
+    setWorkspacePreviewScopeIds((current) => omitProjectWorkspaceEntries(current, projectId));
+    setSemanticBlockEditModes((current) => omitProjectWorkspaceEntries(current, projectId));
+    setSemanticBlockEditProjectModes((current) => omitProjectWorkspaceEntries(current, projectId));
+    setWorkspaceTextInspectorModes((current) => omitProjectWorkspaceEntries(current, projectId));
+    setWorkspaceTextInspectorSelections((current) => omitProjectWorkspaceEntries(current, projectId));
+    setWorkspaceSemanticBlockOverrides((current) => omitProjectWorkspaceEntries(current, projectId));
+    setWorkspaceSemanticBlockDrafts((current) => omitProjectWorkspaceEntries(current, projectId));
+    setSelectedSemanticBlockIds((current) => omitProjectWorkspaceEntries(current, projectId));
+    setSemanticBlockGenerationDirty((current) => omitProjectWorkspaceEntries(current, projectId));
+    setPageWorkspaces((current) => omitProjectWorkspaceEntries(current, projectId));
+    setWorkspaceDraftTexts((current) => omitProjectWorkspaceEntries(current, projectId));
+    setWorkspaceSectionTexts((current) => omitProjectWorkspaceEntries(current, projectId));
+    setWorkspaceContentFieldTexts((current) => omitProjectWorkspaceEntries(current, projectId));
+    setWorkspacePreviewModes((current) => omitProjectWorkspaceEntries(current, projectId));
+    setActiveVisualComposerConfigIds((current) => omitProjectWorkspaceEntries(current, projectId));
+    setVisualComposerConfigs((current) => omitProjectWorkspaceEntries(current, projectId));
+    setVisualComposerVariantContracts((current) => omitProjectWorkspaceEntries(current, projectId));
+    setBusyWorkspaceKey((current) =>
+      current && (current === projectId || current.startsWith(workspacePrefix)) ? null : current
+    );
+
+    return nextGeneration;
+  }
+
   async function handleProjectScan(project: ProjectSummary, options: { hideSuccessMessage?: boolean } = {}) {
     setScanningProjectId(project.id);
     setProjectActionError(null);
@@ -13048,6 +13548,8 @@ export function App() {
     try {
       const result = await runProjectScan(project.id);
 
+      invalidateProjectWorkspaceCaches(project.id);
+
       setScanSummaries((currentSummaries) => ({
         ...currentSummaries,
         [project.id]: result.scan
@@ -15760,6 +16262,14 @@ export function App() {
     const matchingBlocks = (semanticBlocks ?? []).filter((block) => block.workspaceKey === workspaceKey);
 
     if (matchingBlocks.length === 0) {
+      setWorkspaceSemanticBlockOverrides((currentOverrides) => ({
+        ...currentOverrides,
+        [workspaceKey]: []
+      }));
+      setSemanticBlockGenerationDirty((currentDirty) => ({
+        ...currentDirty,
+        [workspaceKey]: false
+      }));
       return;
     }
 
@@ -15785,24 +16295,14 @@ export function App() {
     }
 
     const scanSummary = scanSummaries[projectId] ?? null;
-    const scopeItem =
-      scanSummary
-        ? getSelectedWorkspaceScopeItems(scanSummary).find((item) => item.scopeId === scopeId) ?? null
-        : null;
-    const issues = getPageIssues(scanSummary, scopeItem?.pageId ?? workspace.pageId);
-    const rawTargets = buildWorkspaceTargets(workspace, issues, {
-      includeRewriteTargets: true,
-      includeSectionFallback: true,
-      contentFieldTextMap: workspaceContentFieldTexts[workspaceKey],
-      pageId: scopeItem?.pageId ?? workspace.pageId,
-      rewriteDiff: rewriteDiffContracts[projectId] ?? null,
-      scopeItem
-    });
-    const targets = getWorkspaceTargetsForRewriteRuntime(rawTargets, overrides);
+    const scopeItems = scanSummary ? getSelectedWorkspaceScopeItems(scanSummary) : [];
+    const scopeItemById = new Map(scopeItems.map((item) => [item.scopeId, item]));
+    const canonicalWorkspaceKeys = getSemanticBlockPageWorkspaceKeys(workspaceKey);
+    const targets = getSemanticBlockPageTargets(workspaceKey, overrides);
     const blocks = overrides.flatMap((override) => {
       const sourceBindings = buildSemanticBlockSourceBindings(override, targets);
 
-      if (sourceBindings.length === 0) {
+      if (sourceBindings.length === 0 && override.targetIds.length === 0) {
         return [];
       }
 
@@ -15830,14 +16330,23 @@ export function App() {
     try {
       const result = await savePageSemanticBlocks(projectId, workspace.pageId, {
         blocks,
+        replaceWorkspaces: canonicalWorkspaceKeys.flatMap((canonicalWorkspaceKey) => {
+          const canonicalScopeId = getWorkspaceScopeIdFromWorkspaceKey(canonicalWorkspaceKey);
+          const canonicalScopeItem = scopeItemById.get(canonicalScopeId);
+          return canonicalScopeItem
+            ? [{ pageId: canonicalScopeItem.pageId, scopeId: canonicalScopeId, workspaceKey: canonicalWorkspaceKey }]
+            : [];
+        }),
         scanVersionId: workspace.page.scanVersionId,
         scopeId,
         workspaceKey
       });
       const persistedOverrides = getSemanticBlockOverridesFromModels(result.semanticBlocks, workspaceKey);
+      const clearedWorkspaceOverrides = Object.fromEntries(canonicalWorkspaceKeys.map((canonicalWorkspaceKey) => [canonicalWorkspaceKey, []]));
 
       setWorkspaceSemanticBlockOverrides((currentOverrides) => ({
         ...currentOverrides,
+        ...clearedWorkspaceOverrides,
         [workspaceKey]: persistedOverrides
       }));
       setProjectActionError(null);
@@ -15853,6 +16362,11 @@ export function App() {
     }
   }
 
+  async function persistSemanticBlockPage(workspaceKey: string, overrides: WorkspaceSemanticBlockOverride[]) {
+    const ownerWorkspaceKey = getSemanticBlockOwnerWorkspaceKey(workspaceKey);
+    await persistWorkspaceSemanticBlocks(ownerWorkspaceKey, overrides);
+  }
+
   async function handleOpenPageWorkspace(
     project: ProjectSummary,
     target: ProjectScanSummary["pages"][number] | WorkspaceScopeItem,
@@ -15863,9 +16377,10 @@ export function App() {
     const scopeId = isScopeItem ? target.scopeId : getPageScopeId(target);
     const workspaceTitle = isScopeItem ? target.title : getPageTitle(target);
     const workspaceKey = getWorkspaceKey(project.id, scopeId);
+    const workspaceGeneration = getProjectWorkspaceGeneration(project.id);
+    const cachedWorkspace = pageWorkspaces[workspaceKey];
 
     pendingActiveWorkspaceScopeIdsRef.current[project.id] = scopeId;
-    setBusyWorkspaceKey(workspaceKey);
 
     if (!options.silent) {
       setProjectActionError(null);
@@ -15884,15 +16399,32 @@ export function App() {
       }));
     }
 
-    if (!options.deferActiveUntilLoaded) {
+    if (!options.deferActiveUntilLoaded || cachedWorkspace) {
       setActiveWorkspaceScopeIds((currentScopeIds) => ({
         ...currentScopeIds,
         [project.id]: scopeId
       }));
     }
 
-	    try {
-	      const result = await openPageWorkspace(project.id, pageId);
+    // Reopening an already hydrated scope is navigation, not a reload. Keeping
+    // the local text maps here is essential: a drawer click must not overwrite
+    // unsaved Stage 7 edits with the backend snapshot.
+    if (cachedWorkspace) {
+      if (!options.silent) {
+        setProjectActionMessage(`Рабочая зона открыта: ${workspaceTitle}.`);
+      }
+      return;
+    }
+
+    setBusyWorkspaceKey(workspaceKey);
+
+    try {
+	      const result = await requestPageWorkspace(project.id, pageId, workspaceGeneration);
+
+      if (getProjectWorkspaceGeneration(project.id) !== workspaceGeneration) {
+        return;
+      }
+
 	      const contentFieldTextMap = getContentFieldDraftTextMap(result.contentDrafts);
       hydratePersistedWorkspaceSemanticBlocks(workspaceKey, result.semanticBlocks);
 
@@ -15939,23 +16471,52 @@ export function App() {
         setProjectActionMessage(`Рабочая зона открыта: ${workspaceTitle}.`);
       }
     } catch (error: unknown) {
-      setProjectActionError(getErrorMessage(error, "Не удалось открыть рабочую зону страницы."));
+      if (getProjectWorkspaceGeneration(project.id) === workspaceGeneration) {
+        setProjectActionError(getErrorMessage(error, "Не удалось открыть рабочую зону страницы."));
+      }
     } finally {
-      setBusyWorkspaceKey(null);
+      if (getProjectWorkspaceGeneration(project.id) === workspaceGeneration) {
+        setBusyWorkspaceKey((current) => (current === workspaceKey ? null : current));
+      }
     }
   }
 
+  function requestPageWorkspace(projectId: string, pageId: string, workspaceGeneration = getProjectWorkspaceGeneration(projectId)) {
+    const requestKey = `${projectId}:${workspaceGeneration}:${pageId}`;
+    const currentRequest = pageWorkspaceRequestPromisesRef.current.get(requestKey);
+
+    if (currentRequest) {
+      return currentRequest;
+    }
+
+    const request = openPageWorkspace(projectId, pageId).finally(() => {
+      if (pageWorkspaceRequestPromisesRef.current.get(requestKey) === request) {
+        pageWorkspaceRequestPromisesRef.current.delete(requestKey);
+      }
+    });
+
+    pageWorkspaceRequestPromisesRef.current.set(requestKey, request);
+    return request;
+  }
+
   async function prefetchPageWorkspace(project: ProjectSummary, scopeItem: WorkspaceScopeItem) {
     const workspaceKey = getWorkspaceKey(project.id, scopeItem.scopeId);
+    const workspaceGeneration = getProjectWorkspaceGeneration(project.id);
+    const prefetchKey = `${workspaceKey}:generation:${workspaceGeneration}`;
 
-    if (pageWorkspaces[workspaceKey] || busyWorkspaceKey === workspaceKey || prefetchingWorkspaceKeysRef.current.has(workspaceKey)) {
+    if (pageWorkspaces[workspaceKey] || busyWorkspaceKey === workspaceKey || prefetchingWorkspaceKeysRef.current.has(prefetchKey)) {
       return;
     }
 
-    prefetchingWorkspaceKeysRef.current.add(workspaceKey);
+    prefetchingWorkspaceKeysRef.current.add(prefetchKey);
 
 	    try {
-	      const result = await openPageWorkspace(project.id, scopeItem.pageId);
+	      const result = await requestPageWorkspace(project.id, scopeItem.pageId, workspaceGeneration);
+
+      if (getProjectWorkspaceGeneration(project.id) !== workspaceGeneration) {
+        return;
+      }
+
 	      const contentFieldTextMap = getContentFieldDraftTextMap(result.contentDrafts);
       hydratePersistedWorkspaceSemanticBlocks(workspaceKey, result.semanticBlocks);
 
@@ -15990,7 +16551,9 @@ export function App() {
         [workspaceKey]: currentTargetIds[workspaceKey] ?? result.workspace.sections[0]?.id ?? ""
       }));
     } catch {
-      prefetchingWorkspaceKeysRef.current.delete(workspaceKey);
+      // Prefetch is best-effort; explicit open reports actionable failures.
+    } finally {
+      prefetchingWorkspaceKeysRef.current.delete(prefetchKey);
     }
   }
 
@@ -16452,7 +17015,8 @@ export function App() {
     pageId: string | null,
     pageTitle: string | null,
     targets: WorkspaceTarget[],
-    sectionTextMap: WorkspaceSectionTextMap | undefined
+    sectionTextMap: WorkspaceSectionTextMap | undefined,
+    semanticGroupContextTexts?: Record<string, string[]>
   ) {
     setGeneratingVisualComposerProjectId(projectId);
     setProjectActionError(null);
@@ -16460,7 +17024,7 @@ export function App() {
     setProjectActionProjectId(projectId);
 
     try {
-      const seeds = buildVisualComposerSeedInputs(pageId, pageTitle, targets, sectionTextMap);
+      const seeds = buildVisualComposerSeedInputs(pageId, pageTitle, targets, sectionTextMap, semanticGroupContextTexts);
       const result = await generateVisualComposerVariants(projectId, seeds);
       const variants = result.visualComposerVariants;
       const firstGeneratedConfig = getVisualComposerGeneratedConfigurations(variants)[0] ?? null;
@@ -16480,13 +17044,21 @@ export function App() {
           const pageSnapshot = firstGeneratedConfig.sectionTextsByPageId?.[pageId] ?? null;
 
           if (pageSnapshot && Object.keys(pageSnapshot).length > 0) {
-            setWorkspaceSectionTexts((currentTexts) => ({
-              ...currentTexts,
-              [workspaceKey]: {
-                ...(currentTexts[workspaceKey] ?? sectionTextMap ?? {}),
-                ...pageSnapshot
-              }
-            }));
+            setWorkspaceSectionTexts((currentTexts) => {
+              const nextTexts = { ...currentTexts };
+
+              targets.forEach((target) => {
+                const nextValue = pageSnapshot[target.sectionId];
+                if (typeof nextValue !== "string") return;
+                const targetWorkspaceKey = (target as SemanticBlockBindingTarget).semanticSourceWorkspaceKey ?? workspaceKey;
+                nextTexts[targetWorkspaceKey] = {
+                  ...(nextTexts[targetWorkspaceKey] ?? {}),
+                  [target.sectionId]: nextValue
+                };
+              });
+
+              return nextTexts;
+            });
           }
         }
       }
@@ -16623,6 +17195,21 @@ export function App() {
     });
   }
 
+  function updateWorkspaceScopeQuery(workspaceKey: string, query: string) {
+    setWorkspaceScopeQueries((currentQueries) => {
+      if (!query) {
+        const nextQueries = { ...currentQueries };
+        delete nextQueries[workspaceKey];
+        return nextQueries;
+      }
+
+      return {
+        ...currentQueries,
+        [workspaceKey]: query
+      };
+    });
+  }
+
   function serializeSemanticBlockEditBoxes(boxes: Array<WorkspaceSemanticBlockOverride | WorkspaceSemanticBlockDraftBox> = []) {
     return boxes.map((box) => ({
       anchors: box.anchors,
@@ -16673,9 +17260,14 @@ export function App() {
     const semanticBlockBoxes = semanticBlockEditModeEnabled
       ? serializeSemanticBlockEditBoxes(getSemanticBlockEditBoxes(workspaceKey))
       : [];
-	  const activePreviewSourceKey = getWorkspaceScopePreviewSourceKey(activeScopeItem);
-	  const previewScopeItems = activePreviewSourceKey
-	    ? scopeItems.filter((item) => getWorkspaceScopePreviewSourceKey(item) === activePreviewSourceKey)
+	  const scanSummary = scanSummaries[projectId] ?? null;
+	  const activeRenderedPageKey = scanSummary
+	    ? getWorkspaceRenderedPageKey(activeScopeItem, scopeItems, scanSummary)
+	    : "";
+	  const previewScopeItems = activeRenderedPageKey && scanSummary
+	    ? scopeItems.filter(
+	        (item) => getWorkspaceRenderedPageKey(item, scopeItems, scanSummary) === activeRenderedPageKey
+	      )
 	    : activeScopeItem
 	      ? [activeScopeItem]
 	      : [];
@@ -16686,9 +17278,11 @@ export function App() {
         workspaceKey,
         activePageId: activeScopeItem?.pageId ?? "",
         activeScopeId: activeScopeItem?.scopeId ?? "",
+        editorSessionKey: getSemanticBlockEditorSessionKey(workspaceKey),
         hasManualSemanticBlockSet: semanticBlockEditModeEnabled ? hasSemanticBlockManualSet(workspaceKey) : false,
         semanticBlockBoxes,
         semanticBlockEditMode: semanticBlockEditModeEnabled,
+        textInspectorMode: Boolean(workspaceTextInspectorModes[projectId]),
         scopePages: previewScopeItems
           .map((item) => ({
             label: item.title,
@@ -16728,7 +17322,7 @@ export function App() {
                 !shouldAnchorToRenderedSection &&
                 (target.sectionId === "seo-title" || target.sectionId === "seo-description" || target.sectionId === "seo-h1"),
               sectionId: target.sectionId,
-              markerVisible: shouldShowWorkspacePreviewMarker(target),
+              markerVisible: activeStageIndex !== 6 && shouldShowWorkspacePreviewMarker(target),
               semanticBlockEditable: isSemanticBlockEditorTarget(target),
               semanticGroup: target.semanticGroup
                 ? {
@@ -16770,25 +17364,127 @@ export function App() {
 	    );
 	  }
 
+  function getSemanticBlockPageWorkspaceKeys(workspaceKey: string) {
+    const projectId = getWorkspaceUiKeyFromWorkspaceKey(workspaceKey);
+    const scopeId = getWorkspaceScopeIdFromWorkspaceKey(workspaceKey);
+    const scanSummary = scanSummaries[projectId];
+
+    if (!scanSummary) return [workspaceKey];
+
+  const scopeItems = getSelectedWorkspaceScopeItems(scanSummary);
+  const scopeItem = scopeItems.find((item) => item.scopeId === scopeId) ?? null;
+  const renderedPageKey = getWorkspaceRenderedPageKey(scopeItem, scopeItems, scanSummary);
+
+  if (!renderedPageKey) return [workspaceKey];
+
+  const renderedPageItems = scopeItems
+      .filter((item) => getWorkspaceRenderedPageKey(item, scopeItems, scanSummary) === renderedPageKey)
+      .sort((left, right) => {
+        if (left.kind !== right.kind) return left.kind === "page" ? -1 : 1;
+        return left.order - right.order || left.scopeId.localeCompare(right.scopeId, "ru");
+      });
+    const renderedPageKeys = renderedPageItems.map((item) => getWorkspaceKey(projectId, item.scopeId));
+
+    return Array.from(new Set([
+      ...renderedPageKeys,
+      workspaceKey
+    ]));
+  }
+
+  function getSemanticBlockOwnerWorkspaceKey(workspaceKey: string) {
+    return getSemanticBlockPageWorkspaceKeys(workspaceKey)[0] ?? workspaceKey;
+  }
+
+  function getSemanticBlockEditorSessionKey(workspaceKey: string) {
+    const projectId = getWorkspaceUiKeyFromWorkspaceKey(workspaceKey);
+    const scopeId = getWorkspaceScopeIdFromWorkspaceKey(workspaceKey);
+    const scanSummary = scanSummaries[projectId];
+    const scopeItem = scanSummary
+      ? getSelectedWorkspaceScopeItems(scanSummary).find((item) => item.scopeId === scopeId) ?? null
+      : null;
+    const scopeItems = scanSummary ? getSelectedWorkspaceScopeItems(scanSummary) : [];
+    const renderedPageKey = scanSummary
+      ? getWorkspaceRenderedPageKey(scopeItem, scopeItems, scanSummary)
+      : "";
+
+    return `${projectId}:rendered:${renderedPageKey || scopeId || "preview"}`;
+  }
+
   function getSemanticBlockEditBoxes(workspaceKey: string) {
-    if (hasOwnRecordKey(workspaceSemanticBlockDrafts, workspaceKey)) {
-      return workspaceSemanticBlockDrafts[workspaceKey] ?? [];
-    }
+    const boxesById = new Map<string, WorkspaceSemanticBlockOverride | WorkspaceSemanticBlockDraftBox>();
 
-    if (hasOwnRecordKey(workspaceSemanticBlockOverrides, workspaceKey)) {
-      return workspaceSemanticBlockOverrides[workspaceKey] ?? [];
-    }
+    getSemanticBlockPageWorkspaceKeys(workspaceKey).forEach((pageWorkspaceKey) => {
+      const hasDraft = hasOwnRecordKey(workspaceSemanticBlockDrafts, pageWorkspaceKey);
+      const boxes = hasDraft
+        ? workspaceSemanticBlockDrafts[pageWorkspaceKey] ?? []
+        : workspaceSemanticBlockOverrides[pageWorkspaceKey] ?? [];
 
-    return [];
+      boxes.filter((box) => hasDraft || isStage7SemanticMembership(box)).forEach((box) => {
+        const current = boxesById.get(box.id);
+        boxesById.set(box.id, current ? mergeSemanticBlockOverrideMembership(current, box) : box);
+      });
+    });
+
+    return Array.from(boxesById.values());
   }
 
   function hasSemanticBlockManualSet(workspaceKey: string) {
     return (
-      hasOwnRecordKey(workspaceSemanticBlockDrafts, workspaceKey) ||
-      hasOwnRecordKey(workspaceSemanticBlockOverrides, workspaceKey)
+      getSemanticBlockPageWorkspaceKeys(workspaceKey).some((pageWorkspaceKey) =>
+        hasOwnRecordKey(workspaceSemanticBlockDrafts, pageWorkspaceKey)
+      ) || getSemanticBlockEditBoxes(workspaceKey).length > 0
     );
   }
 
+  function getSemanticBlockPageTargets(
+    workspaceKey: string,
+    overrides: WorkspaceSemanticBlockOverride[],
+    options: { filterExcluded?: boolean } = {}
+  ): SemanticBlockBindingTarget[] {
+    const projectId = getWorkspaceUiKeyFromWorkspaceKey(workspaceKey);
+    const scanSummary = scanSummaries[projectId] ?? null;
+    const scopeItems = scanSummary ? getSelectedWorkspaceScopeItems(scanSummary) : [];
+    const scopeItemById = new Map(scopeItems.map((item) => [item.scopeId, item]));
+    const targetsBySourceIdentity = new Map<string, SemanticBlockBindingTarget>();
+
+    getSemanticBlockPageWorkspaceKeys(workspaceKey).forEach((sourceWorkspaceKey) => {
+      const sourceScopeId = getWorkspaceScopeIdFromWorkspaceKey(sourceWorkspaceKey);
+      const sourceScopeItem = scopeItemById.get(sourceScopeId) ?? null;
+      const sourceWorkspace = pageWorkspaces[sourceWorkspaceKey];
+      if (!sourceWorkspace) return;
+
+      const sourceIssues = getWorkspaceScopeIssues(scanSummary, sourceScopeItem);
+      const sourceRawTargets = buildWorkspaceTargets(sourceWorkspace, sourceIssues, {
+        includeRewriteTargets: true,
+        includeSectionFallback: true,
+        contentFieldTextMap: workspaceContentFieldTexts[sourceWorkspaceKey],
+        pageId: sourceScopeItem?.pageId ?? sourceWorkspace.pageId,
+        rewriteDiff: rewriteDiffContracts[projectId] ?? null,
+        scopeItem: sourceScopeItem
+      });
+      const sourceTargets = getWorkspaceTargetsForRewriteRuntime(sourceRawTargets, overrides);
+      const eligibleTargets = options.filterExcluded
+        ? filterExcludedWorkspaceTargets(sourceWorkspaceKey, sourceTargets, excludedWorkspaceTargetIds)
+        : sourceTargets;
+
+      eligibleTargets.forEach((target) => {
+        const enrichedTarget: SemanticBlockBindingTarget = {
+          ...target,
+          semanticSourcePageId: sourceScopeItem?.pageId ?? sourceWorkspace.pageId,
+          semanticSourceScopeId: sourceScopeId,
+          semanticSourceWorkspaceKey: sourceWorkspaceKey
+        };
+        const sourceIdentity = `${sourceWorkspaceKey}\u0000${target.id}`;
+        const currentTarget = targetsBySourceIdentity.get(sourceIdentity);
+        if (!currentTarget || (currentTarget.permission !== "editable" && enrichedTarget.permission === "editable")) {
+          targetsBySourceIdentity.set(sourceIdentity, enrichedTarget);
+        }
+      });
+    });
+
+    return Array.from(targetsBySourceIdentity.values());
+  }
+
   function postSemanticBlockEditMode(
     workspaceKey: string,
     enabled: boolean,
@@ -16804,6 +17500,7 @@ export function App() {
 	      {
 	        type: "seo-mode:set-semantic-block-edit-mode",
 	        workspaceKey,
+	        editorSessionKey: getSemanticBlockEditorSessionKey(workspaceKey),
 	        enabled,
 	        hasManualSemanticBlockSet: enabled ? hasSemanticBlockManualSet(workspaceKey) : false,
 	        semanticBlockBoxes: serializeSemanticBlockEditBoxes(boxes)
@@ -16812,7 +17509,43 @@ export function App() {
 	    );
   }
 
-  function beginSemanticBlockEdit(workspaceKey: string) {
+  function postWorkspaceTextInspectorMode(workspaceKey: string, enabled: boolean) {
+    const frameWindow = previewFrameRefs.current[workspaceKey]?.contentWindow;
+
+    if (!frameWindow) {
+      return;
+    }
+
+    frameWindow.postMessage(
+      {
+        type: "seo-mode:set-text-inspector-mode",
+        workspaceKey,
+        enabled
+      },
+      "*"
+    );
+  }
+
+  function setWorkspaceTextInspectorMode(workspaceKey: string, enabled: boolean) {
+    const projectId = getWorkspaceUiKeyFromWorkspaceKey(workspaceKey);
+    setWorkspaceTextInspectorModes((currentModes) => ({
+      ...currentModes,
+      [projectId]: enabled
+    }));
+
+    if (!enabled) {
+      setWorkspaceTextInspectorSelections((currentSelections) => {
+        if (!currentSelections[projectId]) return currentSelections;
+        const nextSelections = { ...currentSelections };
+        delete nextSelections[projectId];
+        return nextSelections;
+      });
+    }
+
+    postWorkspaceTextInspectorMode(workspaceKey, enabled);
+  }
+
+  function beginSemanticBlockEdit(workspaceKey: string, initialTextUnit: WorkspaceTextInspectorSelection | null = null) {
     if (!SEMANTIC_BLOCK_EDITOR_ENABLED) {
       const projectId = getWorkspaceUiKeyFromWorkspaceKey(workspaceKey);
 
@@ -16824,6 +17557,8 @@ export function App() {
 
     const projectId = getWorkspaceUiKeyFromWorkspaceKey(workspaceKey);
 
+    setWorkspaceTextInspectorMode(workspaceKey, false);
+
     setSemanticBlockEditProjectModes((currentModes) => ({
       ...currentModes,
       [projectId]: true
@@ -16833,28 +17568,44 @@ export function App() {
       [workspaceKey]: true
     }));
     postSemanticBlockEditMode(workspaceKey, true, getSemanticBlockEditBoxes(workspaceKey));
+
+    if (initialTextUnit) {
+      previewFrameRefs.current[workspaceKey]?.contentWindow?.postMessage(
+        {
+          type: "seo-mode:add-text-unit-to-selected-semantic-block",
+          workspaceKey,
+          editorSessionKey: getSemanticBlockEditorSessionKey(workspaceKey),
+          createNewBlock: true,
+          textUnit: initialTextUnit
+        },
+        "*"
+      );
+    }
   }
 
   function cancelSemanticBlockEdit(workspaceKey: string) {
     const projectId = getWorkspaceUiKeyFromWorkspaceKey(workspaceKey);
-    const projectWorkspacePrefix = `${projectId}:`;
+    const pageWorkspaceKeys = getSemanticBlockPageWorkspaceKeys(workspaceKey);
+    const pageWorkspaceKeySet = new Set(pageWorkspaceKeys);
+    const ownerWorkspaceKey = getSemanticBlockOwnerWorkspaceKey(workspaceKey);
 
     setSemanticBlockEditProjectModes((currentModes) => ({
       ...currentModes,
       [projectId]: false
     }));
     setSemanticBlockEditModes((currentModes) => ({
-      ...Object.fromEntries(
-        Object.entries(currentModes).map(([currentWorkspaceKey, enabled]) => [
-          currentWorkspaceKey,
-          currentWorkspaceKey.startsWith(projectWorkspacePrefix) ? false : enabled
-        ])
-      ),
+      ...Object.fromEntries(pageWorkspaceKeys.map((pageWorkspaceKey) => [pageWorkspaceKey, false])),
       [workspaceKey]: false
     }));
     setWorkspaceSemanticBlockDrafts((currentDrafts) =>
-      Object.fromEntries(Object.entries(currentDrafts).filter(([draftWorkspaceKey]) => !draftWorkspaceKey.startsWith(projectWorkspacePrefix)))
+      Object.fromEntries(Object.entries(currentDrafts).filter(([draftWorkspaceKey]) => !pageWorkspaceKeySet.has(draftWorkspaceKey)))
     );
+    setSelectedSemanticBlockIds((currentIds) => {
+      if (!currentIds[ownerWorkspaceKey]) return currentIds;
+      const nextIds = { ...currentIds };
+      delete nextIds[ownerWorkspaceKey];
+      return nextIds;
+    });
     postSemanticBlockEditMode(workspaceKey, false);
   }
 
@@ -16868,7 +17619,8 @@ export function App() {
     frameWindow.postMessage(
       {
         type: "seo-mode:request-semantic-block-commit",
-        workspaceKey
+        workspaceKey,
+        editorSessionKey: getSemanticBlockEditorSessionKey(workspaceKey)
       },
       "*"
     );
@@ -16884,7 +17636,8 @@ export function App() {
     frameWindow.postMessage(
       {
         type: "seo-mode:add-semantic-block",
-        workspaceKey
+        workspaceKey,
+        editorSessionKey: getSemanticBlockEditorSessionKey(workspaceKey)
       },
       "*"
     );
@@ -16900,7 +17653,26 @@ export function App() {
     frameWindow.postMessage(
       {
         type: "seo-mode:delete-selected-semantic-block",
-        workspaceKey
+        workspaceKey,
+        editorSessionKey: getSemanticBlockEditorSessionKey(workspaceKey)
+      },
+      "*"
+    );
+  }
+
+  function renameSelectedSemanticBlock(workspaceKey: string, title: string) {
+    const frameWindow = previewFrameRefs.current[workspaceKey]?.contentWindow;
+
+    if (!frameWindow) {
+      return;
+    }
+
+    frameWindow.postMessage(
+      {
+        type: "seo-mode:rename-selected-semantic-block",
+        workspaceKey,
+        editorSessionKey: getSemanticBlockEditorSessionKey(workspaceKey),
+        title: title.slice(0, 260)
       },
       "*"
     );
@@ -17441,6 +18213,8 @@ export function App() {
     0,
     activeProjectWorkspaceKindItems.findIndex((item) => item.scopeId === activeProjectWorkspaceScopeItem?.scopeId)
   );
+  const activeProjectWorkspacePageCount = activeProjectSelectedWorkspaceScopeItems.filter((item) => item.kind === "page").length;
+  const activeProjectWorkspaceSectionCount = activeProjectSelectedWorkspaceScopeItems.length - activeProjectWorkspacePageCount;
   const activeProjectSiteTitle = getProjectSiteTitle(activeProjectScanSummary);
   const isActiveProjectSelectingPages = activeProject ? selectingPagesProjectId === activeProject.id : false;
   const isActiveProjectScanning = activeProject ? scanningProjectId === activeProject.id : false;
@@ -17467,6 +18241,7 @@ export function App() {
       hasProject: Boolean(activeProject),
       keywordMap: activeLiveKeywordMap,
       marketEnrichment: activeLiveMarketEnrichment,
+      rewritePlan: activeProject ? rewritePlans[activeProject.id] ?? null : null,
       scan: activeProjectScanSummary,
       semanticAnalysis: activeLiveSemanticAnalysis,
       seoStrategy: activeSeoStrategy,
@@ -18140,6 +18915,7 @@ export function App() {
         <button
           className={activeProjectWorkspaceDrawers.includes("pages") ? "active" : undefined}
           onClick={() => toggleWorkspaceDrawer(activeProject.id, "pages")}
+          title={`Страницы: ${activeProjectWorkspacePageCount} · Секции: ${activeProjectWorkspaceSectionCount}`}
           type="button"
         >
           <FileText size={14} />
@@ -18442,30 +19218,68 @@ export function App() {
     setProjectActionMessage(null);
   }
 
-  function getProjectPipelineAccessInput(projectId: string): Parameters<typeof getPipelineStageAccess>[1] {
+  async function hydrateProjectPipelineAccess(
+    projectId: string
+  ): Promise<Parameters<typeof getPipelineStageAccess>[1]> {
+    const cachedScan = scanSummaries[projectId] ?? null;
+    const cachedRewritePlan = rewritePlans[projectId] ?? null;
+    const [scanResult, rewritePlanResult] = await Promise.all([
+      cachedScan ? Promise.resolve(null) : fetchLatestProjectScan(projectId).catch(() => null),
+      cachedRewritePlan ? Promise.resolve(null) : fetchLatestRewritePlan(projectId).catch(() => null)
+    ]);
+
+    const scan = scanResult?.scan ?? cachedScan;
+    const rewritePlan = rewritePlanResult?.rewritePlan ?? cachedRewritePlan;
+    let seoStrategy = seoStrategies[projectId] ?? null;
+
+    if (scanResult) setScanSummaries((current) => ({ ...current, [projectId]: scanResult.scan }));
+    if (rewritePlanResult) setRewritePlans((current) => ({ ...current, [projectId]: rewritePlanResult.rewritePlan }));
+
+    const strategyPromise = fetchLatestSeoStrategy(projectId).catch(() => null);
+    const downstreamHydration = (async () => {
+      const strategyResult = await strategyPromise;
+      if (strategyResult) setSeoStrategies((current) => ({ ...current, [projectId]: strategyResult.strategy }));
+
+      const synthesisResult = await fetchLatestStrategySynthesis(projectId).catch(() => null);
+      if (synthesisResult) setStrategySyntheses((current) => ({ ...current, [projectId]: synthesisResult.strategySynthesis }));
+
+      const qualityResult = await fetchLatestStrategyQualityReview(projectId).catch(() => null);
+      if (qualityResult) setStrategyQualityReviews((current) => ({ ...current, [projectId]: qualityResult.strategyQualityReview }));
+    })();
+
+    if (!rewritePlan && !seoStrategy) {
+      const strategyResult = await strategyPromise;
+      seoStrategy = strategyResult?.strategy ?? null;
+    }
+
+    void downstreamHydration;
+
     const semanticAnalysis = semanticAnalyses[projectId] ?? null;
     const contextReviewRaw = contextReviews[projectId] ?? null;
+    const projectContext = projectContexts[projectId] ?? null;
+    const marketEnrichment = marketEnrichments[projectId] ?? null;
+    const keywordMap = keywordMaps[projectId] ?? null;
+    const strategySynthesis = strategySyntheses[projectId] ?? null;
+    const strategyQualityReview = strategyQualityReviews[projectId] ?? null;
+
     const contextReview =
       semanticAnalysis && contextReviewRaw?.semanticRunId === semanticAnalysis.runId ? contextReviewRaw : null;
 
     return {
       contextReview,
-      projectContext: projectContexts[projectId] ?? null,
+      projectContext,
       hasProject: true,
-      keywordMap: keywordMaps[projectId] ?? null,
-      marketEnrichment: marketEnrichments[projectId] ?? null,
-      scan: scanSummaries[projectId],
+      keywordMap,
+      marketEnrichment,
+      rewritePlan,
+      scan,
       semanticAnalysis,
-      seoStrategy: seoStrategies[projectId] ?? null,
-      strategyQualityReview: strategyQualityReviews[projectId] ?? null,
-      strategySynthesis: strategySyntheses[projectId] ?? null
+      seoStrategy,
+      strategyQualityReview,
+      strategySynthesis
     };
   }
 
-  function getPreferredStageIndexForProject(projectId: string) {
-    return getPreferredProjectStageIndex(getProjectPipelineAccessInput(projectId));
-  }
-
   function openProjectScanStage(project: ProjectSummary) {
     if (editingProjectId === project.id || pendingDeleteProjectId === project.id) {
       return;
@@ -18484,17 +19298,28 @@ export function App() {
     });
   }
 
-  function openProjectFromMenu(project: ProjectSummary) {
-    const nextStageIndex =
-      activeProjectId === project.id && isWorkPanelOpen ? activeStageIndex : getPreferredStageIndexForProject(project.id);
+  async function openProjectFromMenu(project: ProjectSummary) {
+    if (openingProjectId) return;
 
+    const shouldKeepCurrentStage = activeProjectId === project.id && isWorkPanelOpen;
+    setOpeningProjectId(project.id);
     clearProjectActionFeedback();
-    setActiveProjectId(project.id);
-    setActiveStageIndex(nextStageIndex);
-    setIsProjectMenuOpen(false);
-    setIsStageRailOpen(true);
-    setIsWorkPanelOpen(true);
-    setIsWorkPanelFullscreen(false);
+
+    try {
+      const accessInput = await hydrateProjectPipelineAccess(project.id);
+      const nextStageIndex = shouldKeepCurrentStage
+        ? activeStageIndex
+        : getPreferredProjectStageIndex(accessInput);
+
+      setActiveProjectId(project.id);
+      setActiveStageIndex(nextStageIndex);
+      setIsProjectMenuOpen(false);
+      setIsStageRailOpen(true);
+      setIsWorkPanelOpen(true);
+      setIsWorkPanelFullscreen(false);
+    } finally {
+      setOpeningProjectId(null);
+    }
   }
 
   function closeActiveProject() {
@@ -18956,15 +19781,24 @@ export function App() {
                           return (
                             <button
                               className={isCurrent ? "active" : ""}
+                              disabled={Boolean(openingProjectId)}
                               key={project.id}
-                              onClick={() => openProjectFromMenu(project)}
+                              onClick={() => void openProjectFromMenu(project)}
                               role="menuitem"
                               type="button"
                             >
-                              <span>{isCurrent ? <CheckCircle2 size={14} /> : <FolderOpen size={14} />}</span>
+                              <span>
+                                {openingProjectId === project.id
+                                  ? <Loader2 className="spin" size={14} />
+                                  : isCurrent
+                                    ? <CheckCircle2 size={14} />
+                                    : <FolderOpen size={14} />}
+                              </span>
                               <strong>{project.name}</strong>
                               <small>
-                                {scanSummary
+                                {openingProjectId === project.id
+                                  ? "загружаю доступ к этапам..."
+                                  : scanSummary
                                   ? `${scanSummary.counts.pages} страниц · ${scanSummary.counts.assets} ассетов`
                                   : "ждёт инициализации"}
                               </small>
@@ -21979,6 +22813,109 @@ export function App() {
                     const isSemanticBlockEditMode = activeWorkspaceKey
                       ? SEMANTIC_BLOCK_EDITOR_ENABLED && Boolean(semanticBlockEditProjectModes[project.id])
                       : false;
+                    const isTextInspectorMode = activeWorkspaceKey
+                      ? Boolean(workspaceTextInspectorModes[project.id])
+                      : false;
+                    const activeTextInspectorSelection = activeWorkspaceKey
+                      ? workspaceTextInspectorSelections[project.id] ?? null
+                      : null;
+                    const activeTextInspectorTarget = activeTextInspectorSelection?.targetId
+                      ? activeWorkspaceTargets.find((target) => target.id === activeTextInspectorSelection.targetId) ?? null
+                      : null;
+                    const activeTextInspectorCanWrite = Boolean(
+                      activeTextInspectorTarget?.permission === "editable" &&
+                      activeTextInspectorSelection?.editable &&
+                      activeTextInspectorSelection.previewPatchSafe
+                    );
+                    const activeTextInspectorTargetStats = activeTextInspectorTarget
+                      ? getWorkspaceTargetDraftStats(activeTextInspectorTarget, activeWorkspaceSectionTextMap)
+                      : null;
+                    const activeSemanticBlockBoxes = activeWorkspaceKey ? getSemanticBlockEditBoxes(activeWorkspaceKey) : [];
+                    const activeSemanticBlockEditorSessionKey = activeWorkspaceKey
+                      ? getSemanticBlockOwnerWorkspaceKey(activeWorkspaceKey)
+                      : "";
+                    const activeSelectedSemanticBlockId = activeWorkspaceKey
+                      ? selectedSemanticBlockIds[activeSemanticBlockEditorSessionKey] ?? activeSemanticBlockBoxes[0]?.id ?? ""
+                      : "";
+                    const activeSelectedSemanticBlock = activeSemanticBlockBoxes.find(
+                      (box) => box.id === activeSelectedSemanticBlockId
+                    ) ?? null;
+                    const activeSemanticPageTargets = activeWorkspaceKey
+                      ? getSemanticBlockPageTargets(activeWorkspaceKey, activeSemanticBlockBoxes, { filterExcluded: true })
+                      : [];
+                    const activeSelectedSemanticBlockTargetBases = activeSelectedSemanticBlock
+                      ? getSemanticBlockResolvedTargets(activeSelectedSemanticBlock, activeSemanticPageTargets)
+                      : [];
+                    const activeSelectedSemanticBlockTargets = activeSelectedSemanticBlock
+                      ? activeSelectedSemanticBlockTargetBases.map((target, targetIndex) => ({
+                          ...target,
+                          semanticGroup: {
+                            confidence: 1,
+                            evidence: ["manual_semantic_membership"],
+                            fieldCount: activeSelectedSemanticBlockTargetBases.length,
+                            fieldOrder: targetIndex,
+                            fieldRole: target.semanticGroup?.fieldRole ?? target.contentField?.role ?? target.kind,
+                            id: activeSelectedSemanticBlock.id,
+                            source: "workspace_section" as const,
+                            title: activeSelectedSemanticBlock.title,
+                            visualGroupMode: "single" as const
+                          }
+                        }))
+                      : [];
+                    const activeSelectedSemanticBoundAnchorSelectors = new Set(
+                      (activeSelectedSemanticBlock?.anchors ?? [])
+                        .filter((anchor) => Boolean(anchor.targetId && anchor.selector))
+                        .map((anchor) => `${anchor.selector}:${anchor.selectorIndex ?? 0}`)
+                    );
+                    const activeSelectedSemanticAnchoredTargetIds = new Set(
+                      (activeSelectedSemanticBlock?.anchors ?? [])
+                        .filter((anchor) => Boolean(anchor.targetId && anchor.selector))
+                        .map((anchor) => anchor.targetId as string)
+                    );
+                    const activeSelectedSemanticMemberCount = activeSelectedSemanticBlock
+                      ? new Set([
+                          ...activeSelectedSemanticBlock.targetIds
+                            .filter((targetId) => !activeSelectedSemanticAnchoredTargetIds.has(targetId))
+                            .map((targetId) => `target:${targetId}`),
+                          ...(activeSelectedSemanticBlock.anchors ?? [])
+                            .filter((anchor) => Boolean(anchor.targetId && anchor.selector))
+                            .map((anchor) => `target:${anchor.targetId}:${anchor.selector}:${anchor.selectorIndex ?? 0}`),
+                          ...(activeSelectedSemanticBlock.capturedEntities ?? [])
+                            .filter((entity) => !activeSelectedSemanticBoundAnchorSelectors.has(`${entity.selector}:${entity.selectorIndex}`))
+                            .map(
+                            (entity) => `dom:${entity.selector}:${entity.selectorIndex}`
+                            ),
+                          ...(activeSelectedSemanticBlock.anchors ?? [])
+                            .filter((anchor) => !anchor.targetId && anchor.source !== "captured_dom" && Boolean(anchor.selector))
+                            .map((anchor) => `anchor:${anchor.selector}:${anchor.selectorIndex ?? 0}`)
+                        ]).size
+                      : 0;
+                    const activeSelectedSemanticEditableTargetIds = new Set(
+                      activeSelectedSemanticBlockTargets
+                        .filter((target) => target.permission === "editable")
+                        .map((target) => target.id)
+                    );
+                    const activeSelectedSemanticWritableMemberCount = activeSelectedSemanticBlock
+                      ? (activeSelectedSemanticBlock.anchors ?? []).filter(
+                          (anchor) => Boolean(anchor.targetId && activeSelectedSemanticEditableTargetIds.has(anchor.targetId))
+                        ).length + activeSelectedSemanticBlock.targetIds.filter(
+                          (targetId) =>
+                            !activeSelectedSemanticAnchoredTargetIds.has(targetId) &&
+                            activeSelectedSemanticEditableTargetIds.has(targetId)
+                        ).length
+                      : 0;
+                    const activeSemanticPageSectionTextMap = activeWorkspaceKey
+                      ? Object.assign(
+                          {},
+                          ...getSemanticBlockPageWorkspaceKeys(activeWorkspaceKey).map(
+                            (pageWorkspaceKey) => workspaceSectionTexts[pageWorkspaceKey] ?? {}
+                          )
+                        ) as WorkspaceSectionTextMap
+                      : {};
+                    const activeSelectedSemanticContextTexts = (activeSelectedSemanticBlock?.capturedEntities ?? [])
+                      .filter((entity) => !activeSelectedSemanticBoundAnchorSelectors.has(`${entity.selector}:${entity.selectorIndex}`))
+                      .map((entity) => entity.text?.trim() ?? "")
+                      .filter(Boolean);
                     const activeWorkspaceUiKey = project.id;
                     const activeWorkspaceDrawers = WORKSPACE_DRAWER_ORDER.filter((drawer) =>
                       (workspaceDrawers[activeWorkspaceUiKey] ?? []).includes(drawer) &&
@@ -21995,17 +22932,34 @@ export function App() {
                     const previewWorkspaceScopeItem =
                       selectedWorkspaceScopeItems.find((item) => item.scopeId === previewWorkspaceScopeId) ??
                       activeWorkspaceScopeItem;
-                    const activeWorkspacePageIndex = Math.max(
-                      0,
-                      selectedWorkspaceScopeItems.findIndex((item) => item.scopeId === activeWorkspaceScopeItem?.scopeId)
+                    const workspaceScopeQuery = workspaceScopeQueries[project.id] ?? "";
+                    const filteredWorkspaceScopeItems = filterWorkspaceScopeItems(
+                      selectedWorkspaceScopeItems,
+                      workspaceScopeQuery
                     );
-                    const activeWorkspaceKindItems = activeWorkspaceScopeItem
-                      ? selectedWorkspaceScopeItems.filter((item) => item.kind === activeWorkspaceScopeItem.kind)
-                      : [];
+                    const workspacePageScopeItems = selectedWorkspaceScopeItems.filter((item) => item.kind === "page");
+                    const workspaceSectionScopeItems = selectedWorkspaceScopeItems.filter((item) => item.kind === "section");
+                    const activeWorkspaceKindItems = activeWorkspaceScopeItem?.kind === "section"
+                      ? workspaceSectionScopeItems
+                      : workspacePageScopeItems;
                     const activeWorkspaceKindIndex = Math.max(
                       0,
                       activeWorkspaceKindItems.findIndex((item) => item.scopeId === activeWorkspaceScopeItem?.scopeId)
                     );
+                    const filteredWorkspaceScopeGroups = [
+                      {
+                        items: filteredWorkspaceScopeItems.filter((item) => item.kind === "page"),
+                        kind: "page" as const,
+                        label: "Страницы сайта",
+                        total: workspacePageScopeItems.length
+                      },
+                      {
+                        items: filteredWorkspaceScopeItems.filter((item) => item.kind === "section"),
+                        kind: "section" as const,
+                        label: "Секции и блоки",
+                        total: workspaceSectionScopeItems.length
+                      }
+                    ].filter((group) => group.items.length > 0);
                     const activeWorkspacePreviewSourcePath = previewWorkspaceScopeItem
                       ? (previewWorkspaceScopeItem.previewSourcePath ?? previewWorkspaceScopeItem.sourcePath)
                       : "";
@@ -27174,7 +28128,15 @@ export function App() {
                                               <strong>{activeWorkspaceScopeItem.title}</strong>
                                             </div>
                                           </div>
-                                          <section className={`workspace-preview-panel workspace-cockpit-panel ${activeWorkspaceDrawers.length > 0 ? "drawer-open" : ""}`}>
+                                          <section
+                                            className={`workspace-preview-panel workspace-cockpit-panel ${
+                                              activeWorkspaceDrawers.length > 0 ||
+                                              activeTextInspectorSelection ||
+                                              (isSemanticBlockEditMode && activeSelectedSemanticBlock)
+                                                ? "drawer-open"
+                                                : ""
+                                            }`}
+                                          >
                                             <div className="workspace-cockpit-toolbar">
 	                                              <div className="workspace-preview-status">
 	                                                <span>Замечаний на активной странице: {activeWorkspaceIssues.length}</span>
@@ -27196,6 +28158,7 @@ export function App() {
                                                 <button
                                                   className={activeWorkspaceDrawers.includes("pages") ? "active" : undefined}
                                                   onClick={() => toggleWorkspaceDrawer(activeWorkspaceUiKey, "pages")}
+                                                  title={`Страницы: ${workspacePageScopeItems.length} · Секции: ${workspaceSectionScopeItems.length} · ${activeWorkspaceScopeItem.title}`}
                                                   type="button"
                                                 >
                                                   <FileText size={14} />
@@ -27225,6 +28188,26 @@ export function App() {
                                                     <em>{activeWorkspaceRewriteTargetCount}</em>
                                                   </button>
                                                 ) : null}
+                                                {activeStageIndex === 6 ? (
+                                                  <button
+                                                    aria-pressed={isTextInspectorMode}
+                                                    className={isTextInspectorMode ? "active" : undefined}
+                                                    disabled={isSemanticBlockEditMode}
+                                                    onClick={() =>
+                                                      setWorkspaceTextInspectorMode(activeWorkspaceKey, !isTextInspectorMode)
+                                                    }
+                                                    title={
+                                                      isSemanticBlockEditMode
+                                                        ? "Сначала завершите объединение семантических групп"
+                                                        : "Выбрать текстовый элемент на странице"
+                                                    }
+                                                    type="button"
+                                                  >
+                                                    <MousePointer2 size={14} />
+                                                    Текст
+                                                    <em>{activeTextInspectorSelection ? 1 : 0}</em>
+                                                  </button>
+                                                ) : null}
                                                 <div className="workspace-preview-mode-switch" aria-label="Режим зеркала">
                                                   {WORKSPACE_PREVIEW_MODES.map((mode) => (
                                                     <button
@@ -27252,7 +28235,7 @@ export function App() {
                                                         <button
                                                           className="icon-action semantic-block-add"
                                                           onClick={() => addSemanticBlock(activeWorkspaceKey)}
-                                                          title="Добавить semantic block"
+                                                          title="Создать новую семантическую группу"
                                                           type="button"
                                                         >
                                                           <Plus size={16} />
@@ -27260,7 +28243,7 @@ export function App() {
                                                         <button
                                                           className="icon-action semantic-block-delete"
                                                           onClick={() => deleteSelectedSemanticBlock(activeWorkspaceKey)}
-                                                          title="Удалить выбранный semantic block"
+                                                          title="Удалить выбранную семантическую группу"
                                                           type="button"
                                                         >
                                                           <Trash2 size={15} />
@@ -27268,7 +28251,7 @@ export function App() {
                                                         <button
                                                           className="icon-action semantic-block-apply"
                                                           onClick={() => applySemanticBlockEdit(activeWorkspaceKey)}
-                                                          title="Применить рамки"
+                                                          title="Сохранить семантические группы"
                                                           type="button"
                                                         >
                                                           <CheckCircle2 size={16} />
@@ -27276,7 +28259,7 @@ export function App() {
                                                         <button
                                                           className="icon-action semantic-block-cancel"
                                                           onClick={() => cancelSemanticBlockEdit(activeWorkspaceKey)}
-                                                          title="Отменить редактирование рамок"
+                                                          title="Отменить объединение"
                                                           type="button"
                                                         >
                                                           <X size={16} />
@@ -27296,10 +28279,11 @@ export function App() {
                                                           ? cancelSemanticBlockEdit(activeWorkspaceKey)
                                                           : beginSemanticBlockEdit(activeWorkspaceKey)
                                                       }
-                                                      title="Редактировать семантические блоки"
+                                                      title="Объединять текст в семантические группы"
                                                       type="button"
                                                     >
                                                       <SlidersHorizontal size={16} />
+                                                      <span>Группы</span>
                                                     </button>
                                                   </div>
                                                 ) : null}
@@ -27339,6 +28323,12 @@ export function App() {
                                                           ),
                                                         180
                                                       );
+                                                    }
+                                                    if (workspaceTextInspectorModes[project.id]) {
+                                                      window.setTimeout(
+                                                        () => postWorkspaceTextInspectorMode(activeWorkspaceKey, true),
+                                                        200
+                                                      );
                                                     }
 	                                                  }}
                                                   ref={(element) => {
@@ -27360,7 +28350,7 @@ export function App() {
                                                   )}
                                                   title={`Предпросмотр ${activeWorkspaceScopeItem.title}`}
                                                 />
-                                                <div className="workspace-preview-markers">
+                                                {!isVisualComposerMode ? <div className="workspace-preview-markers">
                                                   {activeWorkspaceMarkers.map((marker) => {
                                                     const target = activeWorkspaceTargets.find((item) => item.id === marker.targetId);
 
@@ -27387,9 +28377,11 @@ export function App() {
                                                       </button>
                                                     );
                                                   })}
-                                                </div>
+                                                </div> : null}
                                               </div>
-                                              {activeWorkspaceDrawers.length > 0 ? (
+                                              {activeWorkspaceDrawers.length > 0 ||
+                                              activeTextInspectorSelection ||
+                                              (isSemanticBlockEditMode && activeSelectedSemanticBlock) ? (
                                                 <div className="workspace-drawer-stack">
                                                   {activeWorkspaceDrawers.map((activeWorkspaceDrawer) => {
                                                     const isPagesDrawer = activeWorkspaceDrawer === "pages";
@@ -27443,14 +28435,14 @@ export function App() {
                                                             </span>
                                                             <strong>
                                                               {isPagesDrawer
-                                                                ? `${activeWorkspacePageIndex + 1}/${selectedWorkspaceScopeItems.length}`
+                                                                ? `Страницы: ${workspacePageScopeItems.length} · Секции: ${workspaceSectionScopeItems.length}`
                                                                 : isRewriteDrawer
                                                                   ? `${drawerTargets.length} слотов`
                                                                   : `${drawerTargets.length} замечаний`}
                                                             </strong>
                                                             <small>
                                                               {isPagesDrawer
-                                                                ? "Переключает preview и ошибки рабочей зоны."
+                                                                ? `${activeWorkspaceScopeItem.kind === "section" ? "Секция" : "Страница"} ${activeWorkspaceKindIndex + 1}/${activeWorkspaceKindItems.length} · ${activeWorkspaceScopeItem.title}`
                                                                 : isRewriteDrawer
                                                                   ? isVisualComposerMode
                                                                     ? "Варианты, ручной текст и возврат к оригиналу для активного блока."
@@ -27469,30 +28461,67 @@ export function App() {
                                                         </div>
                                                         {isPagesDrawer ? (
                                                           selectedWorkspaceScopeItems.length > 0 ? (
-                                                            <div className="workspace-page-menu-list workspace-drawer-page-list">
-                                                              {selectedWorkspaceScopeItems.map((scopeItem, pageIndex) => {
-                                                                const pageWorkspaceKey = getWorkspaceKey(project.id, scopeItem.scopeId);
-                                                                const isActivePage = activeWorkspaceScopeItem?.scopeId === scopeItem.scopeId;
-                                                                const isOpening = busyWorkspaceKey === pageWorkspaceKey;
-                                                                const pageIssues = getWorkspaceScopeIssues(scanSummary, scopeItem);
+                                                            <div className="workspace-drawer-page-browser">
+                                                              <label className="workspace-scope-search">
+                                                                <Search aria-hidden="true" size={15} />
+                                                                <input
+                                                                  aria-label="Поиск по выбранным страницам и секциям"
+                                                                  onChange={(event) =>
+                                                                    updateWorkspaceScopeQuery(project.id, event.target.value)
+                                                                  }
+                                                                  placeholder="Найти страницу, URL или блок"
+                                                                  type="search"
+                                                                  value={workspaceScopeQuery}
+                                                                />
+                                                                <span>
+                                                                  {filteredWorkspaceScopeItems.length}/{selectedWorkspaceScopeItems.length}
+                                                                </span>
+                                                              </label>
+                                                              {filteredWorkspaceScopeGroups.length > 0 ? (
+                                                                <div className="workspace-drawer-page-groups">
+                                                                  {filteredWorkspaceScopeGroups.map((group) => (
+                                                                    <section
+                                                                      className="workspace-scope-group"
+                                                                      key={`workspace-scope-group-${group.kind}`}
+                                                                    >
+                                                                      <div className="workspace-scope-group-head">
+                                                                        <strong>{group.label}</strong>
+                                                                        <span>{group.items.length}/{group.total}</span>
+                                                                      </div>
+                                                                      <div className="workspace-page-menu-list workspace-drawer-page-list">
+                                                                        {group.items.map((scopeItem, groupIndex) => {
+                                                                          const pageWorkspaceKey = getWorkspaceKey(project.id, scopeItem.scopeId);
+                                                                          const isActivePage = activeWorkspaceScopeItem?.scopeId === scopeItem.scopeId;
+                                                                          const isOpening = busyWorkspaceKey === pageWorkspaceKey;
+                                                                          const pageIssues = getWorkspaceScopeIssues(scanSummary, scopeItem);
 
-                                                                return (
-                                                                  <button
-                                                                    className={isActivePage ? "active" : undefined}
-                                                                    disabled={isOpening}
-                                                                    key={`workspace-page-drawer-${scopeItem.scopeId}`}
-                                                                    onClick={() => {
-                                                                      void handleOpenPageWorkspace(project, scopeItem, { silent: true });
-                                                                    }}
-                                                                    type="button"
-                                                                  >
-                                                                    <span>{pageIndex + 1}</span>
-                                                                    <strong>{scopeItem.title}</strong>
-                                                                    <small>{scopeItem.pathLabel}</small>
-                                                                    <em>{pageIssues.length} замечаний</em>
-                                                                  </button>
-                                                                );
-                                                              })}
+                                                                          return (
+                                                                            <button
+                                                                              className={isActivePage ? "active" : undefined}
+                                                                              disabled={isOpening}
+                                                                              key={`workspace-page-drawer-${scopeItem.scopeId}`}
+                                                                              onClick={() => {
+                                                                                closeWorkspaceDrawer(activeWorkspaceUiKey, "pages");
+                                                                                void handleOpenPageWorkspace(project, scopeItem, { silent: true });
+                                                                              }}
+                                                                              type="button"
+                                                                            >
+                                                                              <span>{groupIndex + 1}</span>
+                                                                              <strong>{scopeItem.title}</strong>
+                                                                              <small>{scopeItem.pathLabel}</small>
+                                                                              <em>{pageIssues.length} замечаний</em>
+                                                                            </button>
+                                                                          );
+                                                                        })}
+                                                                      </div>
+                                                                    </section>
+                                                                  ))}
+                                                                </div>
+                                                              ) : (
+                                                                <small className="workspace-page-menu-empty">
+                                                                  По запросу ничего не найдено. Все выбранные страницы и секции остаются в наборе.
+                                                                </small>
+                                                              )}
                                                             </div>
                                                           ) : (
                                                             <small className="workspace-page-menu-empty">
@@ -27805,6 +28834,315 @@ export function App() {
                                                       </aside>
                                                     );
                                                   })}
+                                                  {isSemanticBlockEditMode && activeSelectedSemanticBlock ? (
+                                                    <aside className="workspace-drawer workspace-semantic-group-drawer open">
+                                                      <div className="workspace-drawer-header">
+                                                        <div>
+                                                          <span>Семантическая группа</span>
+                                                          <strong>{activeSelectedSemanticBlock.title}</strong>
+                                                          <small>Один ID · несколько адаптивных контуров</small>
+                                                        </div>
+                                                      </div>
+                                                      <div className="workspace-semantic-group-body">
+                                                        <label className="workspace-semantic-group-title">
+                                                          <span>Название смысла</span>
+                                                          <input
+                                                            defaultValue={activeSelectedSemanticBlock.title}
+                                                            key={activeSelectedSemanticBlock.id}
+                                                            onBlur={(event) =>
+                                                              renameSelectedSemanticBlock(activeWorkspaceKey, event.target.value)
+                                                            }
+                                                          />
+                                                        </label>
+                                                        <p className="workspace-semantic-group-guide">
+                                                          Кликайте по любому тексту в preview, чтобы добавить или убрать его. Source binding не нужен для
+                                                          объединения; он нужен только для безопасной записи правки обратно.
+                                                        </p>
+                                                        <dl className="workspace-semantic-group-stats">
+                                                          <div><dt>Фрагментов</dt><dd>{activeSelectedSemanticMemberCount}</dd></div>
+                                                          <div><dt>Можно править</dt><dd>{activeSelectedSemanticWritableMemberCount}</dd></div>
+                                                          <div><dt>Только контекст</dt><dd>{Math.max(0, activeSelectedSemanticMemberCount - activeSelectedSemanticWritableMemberCount)}</dd></div>
+                                                        </dl>
+                                                        {activeSelectedSemanticBlockTargets.length > 0 ? (
+                                                          <section className="workspace-semantic-group-members">
+                                                            <span>Source-bound участники</span>
+                                                            <div>
+                                                              {activeSelectedSemanticBlockTargets.map((target) => (
+                                                                <button
+                                                                  key={`semantic-member-${activeSelectedSemanticBlock.id}-${target.id}`}
+                                                                  onClick={() =>
+                                                                    activateWorkspaceTarget(
+                                                                      target.semanticSourceWorkspaceKey ?? activeWorkspaceKey,
+                                                                      target
+                                                                    )
+                                                                  }
+                                                                  type="button"
+                                                                >
+                                                                  <small>{target.kind}</small>
+                                                                  <strong>{target.title}</strong>
+                                                                </button>
+                                                              ))}
+                                                            </div>
+                                                          </section>
+                                                        ) : (
+                                                          <div className="workspace-text-inspector-unbound">
+                                                            <strong>Контекстная группа</strong>
+                                                            <p>
+                                                              Фрагменты объединены семантически, но пока не имеют writable source binding. Генератор сможет
+                                                              учитывать их как контекст после подтверждения привязки, не перезаписывая DOM напрямую.
+                                                            </p>
+                                                          </div>
+                                                        )}
+                                                        <section className="workspace-semantic-group-functions">
+                                                          <span>Операции над группой</span>
+                                                          <div className="workspace-actions workspace-text-inspector-actions">
+                                                            <button
+                                                              className="tiny-action primary"
+                                                              disabled={
+                                                                generatingVisualComposerProjectId === project.id ||
+                                                                activeSelectedSemanticBlockTargets.length === 0
+                                                              }
+                                                              onClick={() =>
+                                                                void handleRegenerateVisualComposerVariant(
+                                                                  project.id,
+                                                                  activeWorkspaceKey,
+                                                                  activeWorkspace.pageId,
+                                                                  activeWorkspace.page.title,
+                                                                  activeSelectedSemanticBlockTargets,
+                                                                  activeSemanticPageSectionTextMap,
+                                                                  {
+                                                                    [activeSelectedSemanticBlock.id]: activeSelectedSemanticContextTexts
+                                                                  }
+                                                                )
+                                                              }
+                                                              type="button"
+                                                            >
+                                                              {generatingVisualComposerProjectId === project.id ? (
+                                                                <Loader2 className="spin" size={14} />
+                                                              ) : (
+                                                                <RefreshCw size={14} />
+                                                              )}
+                                                              Создать варианты
+                                                            </button>
+                                                            <button
+                                                              className="tiny-action"
+                                                              disabled={activeSelectedSemanticBlockTargets.length === 0}
+                                                              onClick={() =>
+                                                                setWorkspaceSectionTexts((currentTexts) => {
+                                                                  const nextTexts = { ...currentTexts };
+
+                                                                  activeSelectedSemanticBlockTargets.forEach((target) => {
+                                                                    const targetWorkspaceKey = target.semanticSourceWorkspaceKey ?? activeWorkspaceKey;
+                                                                    nextTexts[targetWorkspaceKey] = {
+                                                                      ...(nextTexts[targetWorkspaceKey] ?? {}),
+                                                                      [target.sectionId]: target.originalText
+                                                                    };
+                                                                  });
+
+                                                                  return nextTexts;
+                                                                })
+                                                              }
+                                                              type="button"
+                                                            >
+                                                              <RefreshCw size={14} />
+                                                              Вернуть тексты
+                                                            </button>
+                                                          </div>
+                                                          <small>Balanced · Compact · Offer · Expert · SEO+</small>
+                                                        </section>
+                                                      </div>
+                                                    </aside>
+                                                  ) : null}
+                                                  {activeTextInspectorSelection ? (
+                                                    <aside className="workspace-drawer workspace-text-inspector-drawer open">
+                                                      <div className="workspace-drawer-header">
+                                                        <div>
+                                                          <span>Текстовый фрагмент</span>
+                                                          <strong>{activeTextInspectorTarget?.title ?? activeTextInspectorSelection.text.slice(0, 72)}</strong>
+                                                          <small>
+                                                            {activeTextInspectorCanWrite
+                                                              ? "Можно редактировать через подтверждённый источник"
+                                                              : activeTextInspectorTarget
+                                                                ? "Источник найден; небезопасная прямая запись защищена"
+                                                                : "Можно объединять в смысловую группу; запись в источник пока недоступна"}
+                                                          </small>
+                                                        </div>
+                                                        <button
+                                                          aria-label="Закрыть инспектор"
+                                                          className="workspace-drawer-close"
+                                                          onClick={() => setWorkspaceTextInspectorMode(activeWorkspaceKey, false)}
+                                                          type="button"
+                                                        >
+                                                          <X size={16} />
+                                                        </button>
+                                                      </div>
+                                                      <div className="workspace-text-inspector-body">
+                                                        <div className="workspace-text-inspector-status">
+                                                          <span className={activeTextInspectorSelection.previewPatchSafe ? "ok" : "warning"}>
+                                                            {activeTextInspectorSelection.previewPatchSafe ? "Простой текст" : "Составной текст"}
+                                                          </span>
+                                                          <span className={activeTextInspectorCanWrite ? "ok" : "warning"}>
+                                                            {activeTextInspectorCanWrite
+                                                              ? "Можно записать"
+                                                              : activeTextInspectorTarget
+                                                                ? "Запись защищена"
+                                                                : "Только контекст"}
+                                                          </span>
+                                                          {activeTextInspectorSelection.draftApplied ? <span className="ok">draft</span> : null}
+                                                        </div>
+                                                        <section className="workspace-text-inspector-copy">
+                                                          <span>Текст на странице</span>
+                                                          <p>{activeTextInspectorSelection.text}</p>
+                                                        </section>
+                                                        <dl className="workspace-text-inspector-meta">
+                                                          <div><dt>Роль</dt><dd>{activeTextInspectorSelection.role}</dd></div>
+                                                          <div><dt>Смысловая группа</dt><dd>{activeTextInspectorSelection.semanticBlockId || "не назначена"}</dd></div>
+                                                        </dl>
+                                                        <details className="workspace-text-inspector-technical">
+                                                          <summary>Техническая привязка</summary>
+                                                          <code>{activeTextInspectorSelection.selector}</code>
+                                                          <small>
+                                                            {activeTextInspectorSelection.targetSource} · {Math.round(activeTextInspectorSelection.rect.width)}×
+                                                            {Math.round(activeTextInspectorSelection.rect.height)} px
+                                                          </small>
+                                                        </details>
+                                                        <button
+                                                          className="tiny-action primary workspace-text-group-action"
+                                                          onClick={() => beginSemanticBlockEdit(activeWorkspaceKey, activeTextInspectorSelection)}
+                                                          type="button"
+                                                        >
+                                                          <Plus size={14} />
+                                                          Новая группа из фрагмента
+                                                        </button>
+                                                        {activeTextInspectorSelection.keywordBindings.length > 0 ? (
+                                                          <section className="workspace-text-inspector-keywords">
+                                                            <span>Ключевые назначения</span>
+                                                            <div>
+                                                              {activeTextInspectorSelection.keywordBindings.map((binding, bindingIndex) => (
+                                                                <small key={`inspector-keyword-${bindingIndex}-${binding.phrase ?? binding.role ?? "binding"}`}>
+                                                                  {binding.role ? `${binding.role}: ` : ""}{binding.phrase ?? "без формулировки"}
+                                                                </small>
+                                                              ))}
+                                                            </div>
+                                                          </section>
+                                                        ) : null}
+                                                        {activeTextInspectorTarget && !activeTextInspectorSelection.previewPatchSafe ? (
+                                                          <div className="workspace-text-inspector-unbound">
+                                                            <strong>Live preview защищён</strong>
+                                                            <p>
+                                                              Source-привязка найдена, но элемент содержит вложенную разметку. Рабочий draft можно менять,
+                                                              однако iframe не будет упрощать HTML через textContent; для такого блока нужен сегментный adapter.
+                                                            </p>
+                                                          </div>
+                                                        ) : null}
+                                                        {activeTextInspectorTarget && activeTextInspectorTargetStats ? (
+                                                          <>
+                                                            <label className="workspace-text-inspector-editor">
+                                                              <span>Рабочий текст source binding</span>
+                                                              <textarea
+                                                                disabled={activeTextInspectorTarget.permission !== "editable"}
+                                                                onChange={(event) =>
+                                                                  setWorkspaceSectionTexts((currentTexts) => ({
+                                                                    ...currentTexts,
+                                                                    [activeWorkspaceKey]: {
+                                                                      ...(currentTexts[activeWorkspaceKey] ?? {}),
+                                                                      [activeTextInspectorTarget.sectionId]: event.target.value
+                                                                    }
+                                                                  }))
+                                                                }
+                                                                value={activeTextInspectorTargetStats.draftText}
+                                                              />
+                                                            </label>
+                                                            <div className="workspace-actions workspace-text-inspector-actions">
+                                                              <button
+                                                                className="tiny-action primary"
+                                                                disabled={
+                                                                  isWorkspaceBusy ||
+                                                                  activeTextInspectorTarget.permission !== "editable" ||
+                                                                  !activeTextInspectorTargetStats.hasUnsavedChanges
+                                                                }
+                                                                onClick={() => {
+                                                                  if (activeTextInspectorTarget.source === "content_field") {
+                                                                    void handleSaveContentFieldDraft(
+                                                                      project.id,
+                                                                      activeWorkspace.pageId,
+                                                                      activeWorkspaceKey,
+                                                                      activeTextInspectorTarget
+                                                                    );
+                                                                    return;
+                                                                  }
+
+                                                                  void handleSavePageWorkspace(project.id, activeWorkspace.pageId, activeWorkspaceKey);
+                                                                }}
+                                                                type="button"
+                                                              >
+                                                                {isWorkspaceBusy ? <Loader2 className="spin" size={14} /> : <Save size={14} />}
+                                                                Сохранить
+                                                              </button>
+                                                              <button
+                                                                className="tiny-action"
+                                                                disabled={
+                                                                  generatingVisualComposerProjectId === project.id ||
+                                                                  activeTextInspectorTarget.permission !== "editable"
+                                                                }
+                                                                onClick={() =>
+                                                                  void handleRegenerateVisualComposerVariant(
+                                                                    project.id,
+                                                                    activeWorkspaceKey,
+                                                                    activeWorkspace.pageId,
+                                                                    activeWorkspace.page.title,
+                                                                    [activeTextInspectorTarget],
+                                                                    activeWorkspaceSectionTextMap
+                                                                  )
+                                                                }
+                                                                type="button"
+                                                              >
+                                                                {generatingVisualComposerProjectId === project.id ? (
+                                                                  <Loader2 className="spin" size={14} />
+                                                                ) : (
+                                                                  <RefreshCw size={14} />
+                                                                )}
+                                                                Перегенерировать
+                                                              </button>
+                                                              <button
+                                                                className="tiny-action"
+                                                                disabled={activeTextInspectorTarget.permission !== "editable"}
+                                                                onClick={() =>
+                                                                  setWorkspaceSectionTexts((currentTexts) => ({
+                                                                    ...currentTexts,
+                                                                    [activeWorkspaceKey]: {
+                                                                      ...(currentTexts[activeWorkspaceKey] ?? {}),
+                                                                      [activeTextInspectorTarget.sectionId]: activeTextInspectorTarget.originalText
+                                                                    }
+                                                                  }))
+                                                                }
+                                                                type="button"
+                                                              >
+                                                                <RefreshCw size={14} />
+                                                                К оригиналу
+                                                              </button>
+                                                              <button
+                                                                className="tiny-action"
+                                                                onClick={() => activateWorkspaceTarget(activeWorkspaceKey, activeTextInspectorTarget)}
+                                                                type="button"
+                                                              >
+                                                                <SlidersHorizontal size={14} />
+                                                                Все варианты
+                                                              </button>
+                                                            </div>
+                                                          </>
+                                                        ) : (
+                                                          <div className="workspace-text-inspector-unbound">
+                                                            <strong>Можно объединять, нельзя перезаписывать</strong>
+                                                            <p>
+                                                              Source binding пока не найден, но это не мешает включить текст в единый семантический блок.
+                                                              Прямая запись останется защищённой, чтобы не повредить компонент.
+                                                            </p>
+                                                          </div>
+                                                        )}
+                                                      </div>
+                                                    </aside>
+                                                  ) : null}
                                                 </div>
                                               ) : null}
                                             </div>
diff --git a/seo_mode/seo_mode/app/src/api.ts b/seo_mode/seo_mode/app/src/api.ts
index 4ea421d..28b17ad 100644
--- a/seo_mode/seo_mode/app/src/api.ts
+++ b/seo_mode/seo_mode/app/src/api.ts
@@ -3754,6 +3754,11 @@ export type SemanticBlockModel = {
 };
 
 export type SemanticBlockSaveInput = {
+  replaceWorkspaces?: Array<{
+    pageId: string;
+    scopeId: string;
+    workspaceKey: string;
+  }>;
   scanVersionId?: string | null;
   workspaceKey: string;
   scopeId: string;
diff --git a/seo_mode/seo_mode/app/src/styles.css b/seo_mode/seo_mode/app/src/styles.css
index 7df9b95..8835e53 100644
--- a/seo_mode/seo_mode/app/src/styles.css
+++ b/seo_mode/seo_mode/app/src/styles.css
@@ -17439,20 +17439,22 @@ body:has(.seo-launcher-shell) {
 }
 
 .seo-launcher-shell .workspace.stage-7 .workspace-preview-frame.mobile-preview {
-  display: block !important;
+  display: grid !important;
+  grid-template-columns: minmax(0, 390px) !important;
+  justify-content: center !important;
   overflow: auto !important;
-  padding: 0 !important;
-  background: #ffffff !important;
+  padding: 0.85rem !important;
+  background: #f2f3f2 !important;
 }
 
 .seo-launcher-shell .workspace.stage-7 .workspace-preview-frame.mobile-preview iframe {
   width: 100% !important;
-  min-width: 0 !important;
+  min-width: 320px !important;
   height: 100% !important;
   min-height: 0 !important;
-  border: 0 !important;
-  border-radius: 0 !important;
-  box-shadow: none !important;
+  border: 1px solid rgba(24, 32, 29, 0.12) !important;
+  border-radius: 20px !important;
+  box-shadow: 0 16px 42px rgba(24, 32, 29, 0.12) !important;
 }
 
 .visual-composer-shell {
@@ -17583,22 +17585,22 @@ body:has(.seo-launcher-shell) {
 
 @keyframes semantic-generation-pulse {
   0% {
-    box-shadow: 0 0 0 0 rgba(232, 45, 134, 0.36);
+    box-shadow: 0 0 0 0 rgba(90, 127, 43, 0.34);
   }
 
   70% {
-    box-shadow: 0 0 0 9px rgba(232, 45, 134, 0);
+    box-shadow: 0 0 0 9px rgba(90, 127, 43, 0);
   }
 
   100% {
-    box-shadow: 0 0 0 0 rgba(232, 45, 134, 0);
+    box-shadow: 0 0 0 0 rgba(90, 127, 43, 0);
   }
 }
 
 .tiny-action.needs-regeneration {
   color: #ffffff;
-  background: #e82d86;
-  border-color: #d51f76;
+  background: #5a7f2b;
+  border-color: #4d7023;
   animation: semantic-generation-pulse 1.35s ease-out infinite;
 }
 
@@ -17645,6 +17647,91 @@ body:has(.seo-launcher-shell) {
   font-size: 0.72rem;
 }
 
+.workspace-drawer-page-browser {
+  display: grid;
+  grid-template-rows: auto minmax(0, 1fr);
+  gap: 10px;
+  min-height: 0;
+  padding: 12px;
+  overflow: hidden;
+}
+
+.workspace-scope-search {
+  display: grid;
+  grid-template-columns: auto minmax(0, 1fr) auto;
+  align-items: center;
+  gap: 8px;
+  min-height: 38px;
+  padding: 0 10px;
+  color: var(--muted);
+  background: rgba(255, 255, 255, 0.82);
+  border: 1px solid rgba(24, 32, 29, 0.1);
+  border-radius: 13px;
+}
+
+.workspace-scope-search:focus-within {
+  color: var(--ink);
+  border-color: rgba(24, 32, 29, 0.24);
+  box-shadow: 0 0 0 3px rgba(24, 32, 29, 0.06);
+}
+
+.workspace-scope-search input {
+  min-width: 0;
+  padding: 0;
+  color: var(--ink);
+  background: transparent;
+  border: 0;
+  outline: 0;
+  font: inherit;
+  font-size: 12px;
+  font-weight: 620;
+}
+
+.workspace-scope-search span,
+.workspace-scope-group-head span {
+  color: var(--muted);
+  font-size: 11px;
+  font-weight: 760;
+}
+
+.workspace-drawer-page-groups {
+  display: grid;
+  align-content: start;
+  gap: 14px;
+  min-height: 0;
+  overflow-x: hidden;
+  overflow-y: auto;
+  overscroll-behavior: contain;
+  padding-right: 2px;
+  scrollbar-gutter: stable;
+}
+
+.workspace-scope-group {
+  display: grid;
+  gap: 7px;
+  min-width: 0;
+}
+
+.workspace-scope-group-head {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 8px;
+  padding: 0 2px;
+}
+
+.workspace-scope-group-head strong {
+  color: var(--ink);
+  font-size: 12px;
+  font-weight: 790;
+}
+
+.workspace-drawer-page-browser .workspace-drawer-page-list {
+  max-height: none;
+  overflow: visible;
+  padding: 0;
+}
+
 .semantic-block-edit-controls .icon-action {
   display: inline-grid;
   width: 38px;
@@ -17670,14 +17757,29 @@ body:has(.seo-launcher-shell) {
 }
 
 .semantic-block-edit-controls .semantic-block-toggle {
-  color: #e82d86;
-  border-color: #e82d86;
+  display: inline-flex;
+  width: auto;
+  min-width: 32px;
+  align-items: center;
+  gap: 0.34rem;
+  padding: 0 0.62rem;
+  color: #5a7f2b;
+  border-color: #5a7f2b;
+}
+
+.semantic-block-edit-controls .semantic-block-toggle span {
+  font-size: 0.7rem;
+  font-weight: 820;
+}
+
+.stage-7 .semantic-block-edit-controls .semantic-block-toggle {
+  width: auto;
 }
 
 .semantic-block-edit-controls .semantic-block-toggle.active {
   color: #ffffff;
-  background: #e82d86;
-  border-color: #e82d86;
+  background: #5a7f2b;
+  border-color: #5a7f2b;
 }
 
 .semantic-block-edit-controls .semantic-block-apply {
@@ -17686,8 +17788,8 @@ body:has(.seo-launcher-shell) {
 }
 
 .semantic-block-edit-controls .semantic-block-add {
-  color: #e82d86;
-  border-color: #e82d86;
+  color: #5a7f2b;
+  border-color: #5a7f2b;
 }
 
 .semantic-block-edit-controls .semantic-block-delete {
@@ -17700,6 +17802,289 @@ body:has(.seo-launcher-shell) {
   border-color: #5a7f2b;
 }
 
+.workspace-text-inspector-drawer {
+  flex-basis: min(420px, calc(100% - 24px));
+  max-width: 420px;
+}
+
+.workspace-semantic-group-drawer {
+  flex-basis: min(430px, calc(100% - 24px));
+  max-width: 430px;
+}
+
+.workspace-semantic-group-body {
+  min-height: 0;
+  overflow: auto;
+  display: grid;
+  align-content: start;
+  gap: 0.72rem;
+  padding: 0.78rem;
+}
+
+.workspace-semantic-group-title {
+  display: grid;
+  gap: 0.34rem;
+}
+
+.workspace-semantic-group-title span,
+.workspace-semantic-group-members > span,
+.workspace-semantic-group-functions > span {
+  color: var(--muted);
+  font-size: 0.7rem;
+  font-weight: 780;
+}
+
+.workspace-semantic-group-title input {
+  min-height: 38px;
+  padding: 0 0.66rem;
+  color: var(--ink);
+  background: #fff;
+  border: 1px solid rgba(24, 32, 29, 0.14);
+  border-radius: 10px;
+  font: inherit;
+  font-size: 0.82rem;
+  font-weight: 760;
+}
+
+.workspace-semantic-group-guide {
+  margin: 0;
+  padding: 0.72rem;
+  color: #40532a;
+  background: rgba(90, 127, 43, 0.09);
+  border: 1px solid rgba(90, 127, 43, 0.2);
+  border-radius: 12px;
+  font-size: 0.78rem;
+  line-height: 1.45;
+}
+
+.workspace-semantic-group-stats {
+  display: grid;
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+  gap: 0.4rem;
+  margin: 0;
+}
+
+.workspace-semantic-group-stats div {
+  min-width: 0;
+  padding: 0.58rem;
+  background: #f7f8f7;
+  border: 1px solid rgba(24, 32, 29, 0.09);
+  border-radius: 10px;
+}
+
+.workspace-semantic-group-stats dt {
+  color: var(--muted);
+  font-size: 0.62rem;
+  font-weight: 740;
+}
+
+.workspace-semantic-group-stats dd {
+  margin: 0.16rem 0 0;
+  color: var(--ink);
+  font-size: 1rem;
+  font-weight: 850;
+}
+
+.workspace-semantic-group-members,
+.workspace-semantic-group-functions {
+  display: grid;
+  gap: 0.42rem;
+}
+
+.workspace-semantic-group-members > div {
+  display: grid;
+  gap: 0.34rem;
+}
+
+.workspace-semantic-group-members button {
+  display: grid;
+  gap: 0.08rem;
+  padding: 0.56rem 0.62rem;
+  text-align: left;
+  background: #fff;
+  border: 1px solid rgba(24, 32, 29, 0.1);
+  border-radius: 10px;
+  cursor: pointer;
+}
+
+.workspace-semantic-group-members button small {
+  color: var(--muted);
+  font-size: 0.62rem;
+  font-weight: 740;
+}
+
+.workspace-semantic-group-members button strong {
+  overflow: hidden;
+  color: var(--ink);
+  font-size: 0.76rem;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.workspace-semantic-group-functions > small {
+  color: var(--muted);
+  font-size: 0.66rem;
+}
+
+.workspace-text-group-action {
+  justify-content: center;
+}
+
+.workspace-text-inspector-body {
+  min-height: 0;
+  overflow: auto;
+  display: grid;
+  align-content: start;
+  gap: 0.72rem;
+  padding: 0.78rem;
+}
+
+.workspace-text-inspector-status {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.34rem;
+}
+
+.workspace-text-inspector-status span {
+  padding: 0.28rem 0.5rem;
+  color: #52605a;
+  background: #f1f3f2;
+  border: 1px solid rgba(24, 32, 29, 0.1);
+  border-radius: 999px;
+  font-size: 0.66rem;
+  font-weight: 800;
+  letter-spacing: 0.02em;
+}
+
+.workspace-text-inspector-status span.ok {
+  color: #355718;
+  background: #eef5e8;
+  border-color: rgba(90, 127, 43, 0.24);
+}
+
+.workspace-text-inspector-status span.warning {
+  color: #805c13;
+  background: #fff8e8;
+  border-color: rgba(166, 119, 26, 0.22);
+}
+
+.workspace-text-inspector-copy,
+.workspace-text-inspector-keywords,
+.workspace-text-inspector-unbound,
+.workspace-text-inspector-technical {
+  display: grid;
+  gap: 0.38rem;
+  padding: 0.7rem;
+  background: #f7f8f7;
+  border: 1px solid rgba(24, 32, 29, 0.09);
+  border-radius: 12px;
+}
+
+.workspace-text-inspector-copy > span,
+.workspace-text-inspector-keywords > span,
+.workspace-text-inspector-editor > span {
+  color: var(--muted);
+  font-size: 0.7rem;
+  font-weight: 780;
+}
+
+.workspace-text-inspector-copy p,
+.workspace-text-inspector-unbound p {
+  margin: 0;
+  color: var(--ink);
+  font-size: 0.82rem;
+  line-height: 1.45;
+}
+
+.workspace-text-inspector-meta {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 0.42rem;
+  margin: 0;
+}
+
+.workspace-text-inspector-meta div {
+  min-width: 0;
+  padding: 0.58rem;
+  background: #fff;
+  border: 1px solid rgba(24, 32, 29, 0.09);
+  border-radius: 10px;
+}
+
+.workspace-text-inspector-meta dt {
+  color: var(--muted);
+  font-size: 0.65rem;
+  font-weight: 740;
+}
+
+.workspace-text-inspector-meta dd {
+  overflow: hidden;
+  margin: 0.18rem 0 0;
+  color: var(--ink);
+  font-size: 0.76rem;
+  font-weight: 760;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.workspace-text-inspector-technical summary {
+  color: var(--ink);
+  cursor: pointer;
+  font-size: 0.74rem;
+  font-weight: 760;
+}
+
+.workspace-text-inspector-technical code {
+  overflow-wrap: anywhere;
+  color: #52605a;
+  font-size: 0.66rem;
+  line-height: 1.45;
+}
+
+.workspace-text-inspector-technical small {
+  color: var(--muted);
+  font-size: 0.66rem;
+}
+
+.workspace-text-inspector-keywords > div {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.34rem;
+}
+
+.workspace-text-inspector-keywords small {
+  padding: 0.3rem 0.48rem;
+  color: #31495a;
+  background: #edf3f6;
+  border-radius: 999px;
+  font-size: 0.65rem;
+  font-weight: 720;
+}
+
+.workspace-text-inspector-editor {
+  display: grid;
+  gap: 0.38rem;
+}
+
+.workspace-text-inspector-editor textarea {
+  min-height: 128px;
+  resize: vertical;
+}
+
+.workspace-text-inspector-actions {
+  align-items: stretch;
+}
+
+.workspace-text-inspector-actions .tiny-action {
+  flex: 1 1 calc(50% - 0.3rem);
+  justify-content: center;
+}
+
+.workspace-text-inspector-unbound strong {
+  color: #805c13;
+  font-size: 0.78rem;
+}
+
 .visual-page-settings {
   display: grid;
   gap: 0.55rem;
diff --git a/seo_mode/seo_mode/server/src/preview/routes.ts b/seo_mode/seo_mode/server/src/preview/routes.ts
index 2e3c72a..35544c7 100644
--- a/seo_mode/seo_mode/server/src/preview/routes.ts
+++ b/seo_mode/seo_mode/server/src/preview/routes.ts
@@ -358,8 +358,29 @@ function buildPreviewBridgeScript() {
   return `
     <script>
       (() => {
+        const bridgeScriptElement = document.currentScript;
+        const nativeParentPostMessage = window.parent?.postMessage.bind(window.parent);
+        const bridgeSessionToken = globalThis.crypto?.randomUUID?.() ||
+          Array.from(globalThis.crypto?.getRandomValues?.(new Uint32Array(4)) || [Date.now(), Math.random()])
+            .map((value) => Number(value).toString(36))
+            .join("-");
+        const postBridgeMessage = (message) => {
+          nativeParentPostMessage?.({ ...message, bridgeSessionToken }, "*");
+        };
+        const announceBridge = () => postBridgeMessage({ type: "seo-mode:bridge-ready" });
+        const isTrustedParentMessage = (event) => event.isTrusted && event.source === window.parent;
+
+        // Run before imported page scripts and remove the capability-bearing
+        // bridge source from the DOM. Imported scripts can still render the
+        // page, but cannot forge authenticated editor messages.
+        bridgeScriptElement?.remove();
+        announceBridge();
+        document.addEventListener("DOMContentLoaded", announceBridge, { once: true });
+        window.addEventListener("load", announceBridge, { once: true });
+
         const state = {
           workspaceKey: "",
+          editorSessionKey: "",
           targets: [],
           scopePages: [],
           sectionTexts: {},
@@ -374,18 +395,24 @@ function buildPreviewBridgeScript() {
           nextManualSemanticBlockIndex: 1,
           isSemanticBlockPointerActive: false,
           lastSemanticBlockLocalEditAt: 0,
-          lastSemanticBlockLocalEditWorkspaceKey: ""
+          lastSemanticBlockLocalEditWorkspaceKey: "",
+          lastSemanticBlockLocalEditSessionKey: "",
+          textInspectorMode: false,
+          selectedTextUnit: null,
+          hoveredTextUnit: null
         };
         const layerId = "seo-mode-preview-marker-layer";
         let frame = 0;
         let lastActivation = { id: "", at: 0 };
         let dynamicLayoutObserver = null;
+        let dynamicResizeObserver = null;
         let dynamicLayoutMeasureTimer = 0;
         let lastDynamicLayoutMeasureAt = 0;
         let pendingMeasureAfterSemanticPointer = false;
         let scrollReportFrame = 0;
         let scrollMeasureTimer = 0;
         let textCandidateCache = null;
+        const migratedLegacySemanticBlockWorkspaceKeys = new Set();
         const appliedSectionTexts = new Map();
 
         function ensureLayer() {
@@ -602,10 +629,16 @@ function buildPreviewBridgeScript() {
         }
 
         function getTargetElement(target, options) {
-          const applied = appliedSectionTexts.get(target.sectionId || "");
+          const selectors = Array.isArray(target.selectors) && target.selectors.length > 0
+            ? target.selectors
+            : [target.selector].filter(Boolean);
 
-          if (applied?.element && applied.element.isConnected) {
-            return applied.element;
+          // Scanner/source locators are authoritative. Text is only a
+          // relocation fallback: repeated copy must never override an exact
+          // selector + occurrence binding.
+          for (const selector of selectors) {
+            const element = getElementForSelector(selector, target.selectorIndex);
+            if (element) return element;
           }
 
           const textElement = getTextMatchElement(target, options);
@@ -614,15 +647,6 @@ function buildPreviewBridgeScript() {
             return textElement;
           }
 
-          const selectors = Array.isArray(target.selectors) && target.selectors.length > 0
-            ? target.selectors
-            : [target.selector].filter(Boolean);
-
-          for (const selector of selectors) {
-            const element = getElementForSelector(selector, target.selectorIndex);
-            if (element) return element;
-          }
-
           if (target.fallbackSelector) {
             return getElementForSelector(target.fallbackSelector, target.fallbackSelectorIndex);
           }
@@ -659,6 +683,16 @@ function buildPreviewBridgeScript() {
             return false;
           }
 
+          const computedStyle = window.getComputedStyle(element);
+
+          if (
+            computedStyle.display === "none" ||
+            computedStyle.visibility === "hidden" ||
+            Number(computedStyle.opacity) <= 0.01
+          ) {
+            return false;
+          }
+
           const tagName = element.tagName.toLowerCase();
           const blockedTags = new Set([
             "body",
@@ -705,6 +739,640 @@ function buildPreviewBridgeScript() {
           return true;
         }
 
+        const inspectableTextSelector = [
+          "h1", "h2", "h3", "h4", "h5", "h6", "p", "a", "button", "label", "li",
+          "dt", "dd", "blockquote", "figcaption", "caption", "th", "td", "summary", "small",
+          "strong", "em", "span", "input", "textarea"
+        ].join(",");
+        const logicalTextRootSelector = [
+          "h1", "h2", "h3", "h4", "h5", "h6", "p", "a", "button", "label", "li",
+          "dt", "dd", "blockquote", "figcaption", "caption", "th", "td", "summary", "input", "textarea"
+        ].join(",");
+
+        const blockedTextRootTags = new Set([
+          "html", "body", "main", "section", "article", "header", "footer", "nav",
+          "form", "ul", "ol", "table", "tbody", "thead", "tr", "picture", "video",
+          "canvas", "svg", "script", "style", "noscript"
+        ]);
+
+        function isPointInsideRect(clientX, clientY, rect, tolerance = 3) {
+          return clientX >= rect.left - tolerance && clientX <= rect.right + tolerance &&
+            clientY >= rect.top - tolerance && clientY <= rect.bottom + tolerance;
+        }
+
+        function getTextNodeAtPoint(clientX, clientY) {
+          let node = null;
+
+          if (typeof document.caretPositionFromPoint === "function") {
+            node = document.caretPositionFromPoint(clientX, clientY)?.offsetNode || null;
+          }
+
+          if (!node && typeof document.caretRangeFromPoint === "function") {
+            node = document.caretRangeFromPoint(clientX, clientY)?.startContainer || null;
+          }
+
+          if (node?.nodeType === 3 && normalizeBridgeText(node.textContent || "").length >= 2) {
+            const owner = node.parentElement;
+            if (owner && !owner.closest("#" + layerId)) {
+              const range = document.createRange();
+              range.selectNodeContents(node);
+              const hitsText = Array.from(range.getClientRects()).some((rect) => isPointInsideRect(clientX, clientY, rect, 5));
+              if (hitsText) return node;
+            }
+          }
+
+          const pointElements = typeof document.elementsFromPoint === "function"
+            ? document.elementsFromPoint(clientX, clientY)
+            : [document.elementFromPoint(clientX, clientY)].filter(Boolean);
+          let bestMatch = null;
+
+          for (const pointElement of pointElements) {
+            if (!(pointElement instanceof Element) || pointElement.closest("#" + layerId)) continue;
+
+            // The preview runs inside a deliberately restricted sandbox. Some
+            // customer pages expose neither NodeFilter nor createTreeWalker,
+            // so hit-testing must not depend on either browser global. Walk
+            // childNodes directly and keep the same hard visit limit.
+            const nodes = Array.from(pointElement.childNodes || []);
+            let visited = 0;
+            let cursor = 0;
+
+            while (cursor < nodes.length && visited < 240) {
+              const textNode = nodes[cursor];
+              cursor += 1;
+              visited += 1;
+
+              if (textNode?.nodeType !== 3) {
+                if (textNode?.childNodes?.length) {
+                  nodes.push(...Array.from(textNode.childNodes));
+                }
+                continue;
+              }
+
+              const text = normalizeBridgeText(textNode.textContent || "");
+
+              if (text.length >= 2 && textNode.parentElement && isVisibleElement(textNode.parentElement)) {
+                const range = document.createRange();
+                range.selectNodeContents(textNode);
+
+                for (const rect of Array.from(range.getClientRects())) {
+                  if (!isPointInsideRect(clientX, clientY, rect, 5)) continue;
+
+                  const area = Math.max(1, rect.width * rect.height);
+                  if (!bestMatch || area < bestMatch.area) {
+                    bestMatch = { area, node: textNode };
+                  }
+                }
+              }
+
+            }
+          }
+
+          return bestMatch?.node || null;
+        }
+
+        function getDirectReadableText(element) {
+          if (element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement) {
+            return String(element.value || element.getAttribute("placeholder") || "").replace(/\\s+/g, " ").trim();
+          }
+
+          return Array.from(element.childNodes)
+            .filter((node) => node.nodeType === 3)
+            .map((node) => node.textContent || "")
+            .join(" ")
+            .replace(/\\s+/g, " ")
+            .trim();
+        }
+
+        function isUsableLogicalTextElement(element) {
+          if (!(element instanceof Element) || element.closest("#" + layerId) || !isVisibleElement(element)) return false;
+          if (blockedTextRootTags.has(element.tagName.toLowerCase())) return false;
+
+          const text = normalizeBridgeText(readElementText(element) || element.getAttribute("placeholder") || "");
+          if (text.length < 2 || text.length > 4000) return false;
+
+          const rect = element.getBoundingClientRect();
+          const viewportArea = Math.max(1, window.innerWidth * window.innerHeight);
+          const elementArea = Math.max(0, rect.width) * Math.max(0, rect.height);
+
+          return rect.width > 1 && rect.height > 1 && elementArea <= viewportArea * 0.72;
+        }
+
+        function hasMultipleTextLayoutBranches(element) {
+          const meaningfulChildren = Array.from(element.children).filter((child) => {
+            if (!isVisibleElement(child)) return false;
+            return normalizeBridgeText(readElementText(child)).length >= 2;
+          });
+
+          const layoutBranches = meaningfulChildren.filter((child) => {
+            const display = window.getComputedStyle(child).display;
+            return display === "block" || display === "flex" || display === "grid" || display === "table" || display === "list-item";
+          });
+
+          return layoutBranches.length > 1;
+        }
+
+        function getPresentedTextSourceElement(element) {
+          if (!(element instanceof Element)) return null;
+
+          const presentation = element.closest('[aria-hidden="true"][aria-label]');
+          const label = normalizeBridgeText(presentation?.getAttribute("aria-label") || "");
+          const parent = presentation?.parentElement;
+
+          if (!presentation || !parent || label.length < 2 || !isVisibleElement(presentation)) return null;
+
+          const sources = Array.from(parent.children).filter((candidate) => {
+            if (candidate === presentation || candidate.getAttribute("aria-hidden") === "true") return false;
+            if (normalizeBridgeText(readElementText(candidate)) !== label) return false;
+
+            const style = window.getComputedStyle(candidate);
+            const rect = candidate.getBoundingClientRect();
+            return rect.width > 1 && rect.height > 1 && Number(style.opacity) <= 0.01;
+          });
+          const source = sources.length === 1 ? sources[0] : null;
+
+          if (!(source instanceof Element) || source.closest("#" + layerId)) return null;
+
+          return source;
+        }
+
+        function getPresentedTextVisualElement(element, clientX, clientY) {
+          if (!(element instanceof Element)) return null;
+
+          const directPresentation = element.closest('[aria-hidden="true"][aria-label]');
+
+          if (directPresentation && getPresentedTextSourceElement(directPresentation)) {
+            return directPresentation;
+          }
+
+          let sourceCandidate = element;
+          let ancestorDepth = 0;
+
+          // A pointer event can land on an inline child of the opacity:0
+          // semantic source (for example a highlighted <span>), while the
+          // visible split-text clone is a sibling of the source root. Walk a
+          // small ancestor window so that every point inside the sentence is
+          // resolved to the same visual/logical text unit.
+          while (sourceCandidate?.parentElement && ancestorDepth < 6) {
+            const sourceText = normalizeBridgeText(readElementText(sourceCandidate) || "");
+            const sourceStyle = window.getComputedStyle(sourceCandidate);
+            const sourceRect = sourceCandidate.getBoundingClientRect();
+            const isHiddenSemanticSource =
+              sourceRect.width > 1 && sourceRect.height > 1 && Number(sourceStyle.opacity) <= 0.01;
+
+            if (sourceText.length >= 2 && isHiddenSemanticSource) {
+              const presentations = Array.from(sourceCandidate.parentElement.children).filter((candidate) =>
+                candidate.getAttribute("aria-hidden") === "true" &&
+                normalizeBridgeText(candidate.getAttribute("aria-label") || readElementText(candidate) || "") === sourceText &&
+                isVisibleElement(candidate)
+              );
+              const pointMatches =
+                typeof clientX === "number" && typeof clientY === "number"
+                  ? presentations.filter((candidate) =>
+                      isPointInsideRect(clientX, clientY, candidate.getBoundingClientRect(), 5)
+                    )
+                  : [];
+              const presentation = pointMatches.length === 1
+                ? pointMatches[0]
+                : presentations.length === 1
+                  ? presentations[0]
+                  : null;
+
+              if (presentation && !presentation.closest("#" + layerId)) {
+                return presentation;
+              }
+            }
+
+            sourceCandidate = sourceCandidate.parentElement;
+            ancestorDepth += 1;
+          }
+
+          return null;
+        }
+
+        function hasPresentedTextCompanion(element) {
+          if (!(element instanceof Element)) return false;
+
+          const directPresentation = element.closest('[aria-hidden="true"][aria-label]');
+
+          if (directPresentation) {
+            const label = normalizeBridgeText(directPresentation.getAttribute("aria-label") || "");
+            const parent = directPresentation.parentElement;
+
+            if (
+              label.length >= 2 &&
+              parent &&
+              Array.from(parent.children).some((candidate) => {
+                if (candidate === directPresentation || candidate.getAttribute("aria-hidden") === "true") return false;
+                if (normalizeBridgeText(readElementText(candidate)) !== label) return false;
+                return Number(window.getComputedStyle(candidate).opacity) <= 0.01;
+              })
+            ) {
+              return true;
+            }
+          }
+
+          let sourceCandidate = element;
+          let ancestorDepth = 0;
+
+          while (sourceCandidate?.parentElement && ancestorDepth < 6) {
+            const sourceText = normalizeBridgeText(readElementText(sourceCandidate) || "");
+            const sourceOpacity = Number(window.getComputedStyle(sourceCandidate).opacity);
+
+            if (
+              sourceText.length >= 2 &&
+              sourceOpacity <= 0.01 &&
+              Array.from(sourceCandidate.parentElement.children).some((candidate) =>
+                candidate !== sourceCandidate &&
+                candidate.getAttribute("aria-hidden") === "true" &&
+                normalizeBridgeText(candidate.getAttribute("aria-label") || readElementText(candidate) || "") === sourceText
+              )
+            ) {
+              return true;
+            }
+
+            sourceCandidate = sourceCandidate.parentElement;
+            ancestorDepth += 1;
+          }
+
+          return false;
+        }
+
+        function getLogicalTextElement(textNode, fallbackElement, clientX, clientY) {
+          let element = textNode?.parentElement || (fallbackElement instanceof Element ? fallbackElement : null);
+
+          if (!element || element.closest("#" + layerId)) return null;
+
+          // Animation libraries often keep one opacity:0 source node for
+          // layout and render an aria-hidden clone split into words/letters.
+          // The source node is the stable semantic unit; selecting a visual
+          // word would fragment one sentence into many fake editor entities.
+          const presentedVisual = getPresentedTextVisualElement(element, clientX, clientY);
+          if (presentedVisual) return presentedVisual;
+
+          const nativeRoot = element.closest(logicalTextRootSelector);
+          if (nativeRoot && isUsableLogicalTextElement(nativeRoot)) {
+            return nativeRoot;
+          }
+
+          let candidate = isUsableLogicalTextElement(element) ? element : null;
+          let current = element;
+
+          while (current?.parentElement && current.parentElement !== document.body) {
+            const parent = current.parentElement;
+            if (blockedTextRootTags.has(parent.tagName.toLowerCase()) || !isUsableLogicalTextElement(parent)) break;
+
+            if (parent.matches(logicalTextRootSelector)) {
+              candidate = parent;
+              break;
+            }
+
+            if (hasMultipleTextLayoutBranches(parent)) break;
+
+            const directText = getDirectReadableText(parent);
+            const display = window.getComputedStyle(parent).display;
+            const compactTextComposition =
+              directText.length >= 2 ||
+              display === "inline" ||
+              display === "inline-block" ||
+              display === "contents" ||
+              parent.matches(inspectableTextSelector);
+
+            if (!compactTextComposition) break;
+
+            candidate = parent;
+            current = parent;
+          }
+
+          return candidate;
+        }
+
+        function getInspectableTextElementAtPoint(clientX, clientY, fallbackElement) {
+          const textNode = getTextNodeAtPoint(clientX, clientY);
+          const logicalElement = getLogicalTextElement(textNode, fallbackElement, clientX, clientY);
+
+          if (logicalElement) return logicalElement;
+
+          // Split-text clones normally use pointer-events:none, so the real
+          // event target is frequently their invisible semantic source. Map
+          // that source (or one of its inline children) back to the complete
+          // presented clone before applying ordinary visibility checks.
+          const fallbackPresentation = fallbackElement instanceof Element
+            ? getPresentedTextVisualElement(fallbackElement, clientX, clientY)
+            : null;
+
+          if (fallbackPresentation) {
+            const presentationRect = fallbackPresentation.getBoundingClientRect();
+            if (isPointInsideRect(clientX, clientY, presentationRect, 5)) {
+              return fallbackPresentation;
+            }
+          }
+
+          const fallback = fallbackElement instanceof Element
+            ? fallbackElement.closest(inspectableTextSelector)
+            : null;
+
+          return fallback && isUsableLogicalTextElement(fallback) ? fallback : null;
+        }
+
+        function hashTextUnitIdentity(value) {
+          let hash = 2166136261;
+
+          for (let index = 0; index < value.length; index += 1) {
+            hash ^= value.charCodeAt(index);
+            hash = Math.imul(hash, 16777619);
+          }
+
+          return (hash >>> 0).toString(36);
+        }
+
+        function getTargetTextValues(target) {
+          if (!target) return [];
+
+          const sectionText = target.sectionId && typeof state.sectionTexts?.[target.sectionId] === "string"
+            ? state.sectionTexts[target.sectionId]
+            : "";
+
+          return Array.from(new Set([
+            sectionText,
+            target.workingText,
+            target.originalText,
+            ...getTextNeedles(target)
+          ].map(normalizeBridgeText).filter((value) => value.length >= 2)));
+        }
+
+        function isTargetTextConsistent(target, element) {
+          const elementText = normalizeBridgeText(readElementText(element) || element.getAttribute("placeholder") || "");
+          const targetTexts = getTargetTextValues(target);
+
+          if (!elementText) return false;
+          if (targetTexts.length === 0) return true;
+
+          return targetTexts.some((targetText) => {
+            if (targetText === elementText) return true;
+
+            const compactElementText = elementText.replace(/\\s+/g, "");
+            const compactTargetText = targetText.replace(/\\s+/g, "");
+
+            return compactTargetText.length >= 2 && compactElementText === compactTargetText + compactTargetText;
+          });
+        }
+
+        function getTargetForTextUnit(element) {
+          const matches = state.targets
+            .map((target) => {
+              const targetElement = getTargetElement(target, { clipViewport: false, clipOverflow: false });
+
+              if (!targetElement) return null;
+
+              if (!isTargetTextConsistent(target, element)) return null;
+
+              if (targetElement === element) return { target, score: 0 };
+              if (element.contains(targetElement)) return { target, score: 1 };
+              if (targetElement.contains(element)) return { target, score: 2 };
+
+              return null;
+            })
+            .filter(Boolean)
+            .sort((first, second) => first.score - second.score);
+
+          return matches[0]?.target || null;
+        }
+
+        function getSemanticBlockIdForTextUnit(target, selector, selectorIndex) {
+          const match = state.manualSemanticBlockBoxes.find((box) =>
+            (target?.id && Array.isArray(box.targetIds) && box.targetIds.includes(target.id)) ||
+            (Array.isArray(box.anchors) && box.anchors.some(
+              (anchor) => anchor.selector === selector && Number(anchor.selectorIndex || 0) === selectorIndex
+            )) ||
+            (Array.isArray(box.capturedEntities) && box.capturedEntities.some(
+              (entity) => entity.selector === selector && Number(entity.selectorIndex || 0) === selectorIndex
+            ))
+          );
+
+          return match?.id || target?.semanticBlock?.id || target?.semanticGroup?.id || "";
+        }
+
+        function buildTextUnitPayload(element) {
+          const selector = getElementSelector(element);
+
+          if (!selector) {
+            return null;
+          }
+
+          // Split-text animation libraries often render an aria-hidden visual
+          // clone next to an opacity:0 semantic source. Keep the visual clone
+          // for hit-testing/highlighting, but resolve source bindings through
+          // the semantic sibling when it exists.
+          const semanticSourceElement = getPresentedTextSourceElement(element);
+          const target = getTargetForTextUnit(semanticSourceElement || element) || getTargetForTextUnit(element);
+          const patchElement = semanticSourceElement || element;
+          const selectorIndex = getElementSelectorIndex(element, selector);
+          const previewPatchSafe = !semanticSourceElement && isSafePreviewPatchElement(patchElement);
+          const text = String(
+            element.getAttribute("aria-hidden") === "true"
+              ? element.getAttribute("aria-label") || readElementText(element) || ""
+              : readElementText(element) || element.getAttribute("placeholder") || ""
+          ).replace(/\\s+/g, " ").trim();
+          const rect = getVisibleRect(element, { clipViewport: false, clipOverflow: false });
+          const tagName = element.tagName.toLowerCase();
+
+          if (!rect || text.length < 2) {
+            return null;
+          }
+
+          return {
+            // Text is a relocation fingerprint, not identity: editing a draft
+            // must not turn the same DOM/source unit into another member.
+            id: "text-unit:" + hashTextUnitIdentity(selector + "::" + selectorIndex + "::" + tagName),
+            selector,
+            selectorIndex,
+            tagName,
+            role: target?.kind || tagName,
+            text: text.slice(0, 4000),
+            characterCount: text.length,
+            childElementCount: element.childElementCount,
+            editable: Boolean(target && target.permission === "editable" && previewPatchSafe),
+            previewPatchSafe,
+            draftApplied: element instanceof HTMLElement && element.dataset.seoModeDraft === "true",
+            targetId: target?.id || "",
+            sectionId: target?.sectionId || "",
+            targetTitle: target?.label || target?.title || "",
+            targetSource: target?.source || "unbound_dom",
+            semanticBlockId: getSemanticBlockIdForTextUnit(target, selector, selectorIndex),
+            keywordBindings: Array.isArray(target?.keywordBindings) ? target.keywordBindings.slice(0, 12) : [],
+            rect: getDocumentRect(rect)
+          };
+        }
+
+        function getTextUnitElement(textUnit) {
+          return textUnit?.selector ? getElementForSelector(textUnit.selector, textUnit.selectorIndex) : null;
+        }
+
+        function createTextInspectorHighlight(textUnit, selected) {
+          const element = getTextUnitElement(textUnit);
+          const rect = element ? getVisibleRect(element, { clipViewport: false, clipOverflow: false }) : null;
+
+          if (!element || !rect) {
+            return null;
+          }
+
+          const documentRect = getDocumentRect(rect);
+          const highlight = document.createElement("div");
+          highlight.className = "seo-mode-text-inspector-highlight";
+          highlight.style.position = "absolute";
+          highlight.style.left = Math.max(0, documentRect.left - 4) + "px";
+          highlight.style.top = Math.max(0, documentRect.top - 4) + "px";
+          highlight.style.width = Math.max(2, documentRect.width + 8) + "px";
+          highlight.style.height = Math.max(2, documentRect.height + 8) + "px";
+          highlight.style.border = selected ? "2px solid #18201d" : "1.5px solid rgba(24,32,29,.58)";
+          highlight.style.borderRadius = "8px";
+          highlight.style.background = selected ? "rgba(24,32,29,.065)" : "rgba(24,32,29,.025)";
+          highlight.style.boxShadow = selected ? "0 0 0 3px rgba(255,255,255,.82), 0 10px 28px rgba(24,32,29,.14)" : "none";
+          highlight.style.pointerEvents = "none";
+          highlight.style.zIndex = selected ? "2147483646" : "2147483645";
+
+          if (selected) {
+            const label = document.createElement("span");
+            label.textContent = textUnit.tagName.toUpperCase() + " · " + textUnit.characterCount + " симв.";
+            label.style.position = "absolute";
+            label.style.left = "-2px";
+            label.style.bottom = "calc(100% + 6px)";
+            label.style.padding = "5px 8px";
+            label.style.color = "#fff";
+            label.style.background = "#18201d";
+            label.style.borderRadius = "999px";
+            label.style.font = "700 11px/1 Inter, Arial, sans-serif";
+            label.style.whiteSpace = "nowrap";
+            highlight.appendChild(label);
+          }
+
+          return highlight;
+        }
+
+        function renderTextInspectorHighlights(layer) {
+          if (!state.textInspectorMode) {
+            return;
+          }
+
+          if (state.hoveredTextUnit && state.hoveredTextUnit.id !== state.selectedTextUnit?.id) {
+            const hovered = createTextInspectorHighlight(state.hoveredTextUnit, false);
+            if (hovered) layer.appendChild(hovered);
+          }
+
+          if (state.selectedTextUnit) {
+            const selected = createTextInspectorHighlight(state.selectedTextUnit, true);
+            if (selected) layer.appendChild(selected);
+          }
+        }
+
+        function postTextInspectorSelection(textUnit) {
+          postBridgeMessage({
+            type: "seo-mode:text-unit-select",
+            workspaceKey: state.workspaceKey,
+            editorSessionKey: state.editorSessionKey,
+            textUnit
+          });
+        }
+
+        function clearTextInspectorSelection(report = true) {
+          state.selectedTextUnit = null;
+          state.hoveredTextUnit = null;
+
+          if (report) {
+            postTextInspectorSelection(null);
+          }
+
+          scheduleMeasure();
+        }
+
+        function setTextInspectorMode(enabled) {
+          state.textInspectorMode = Boolean(enabled);
+          document.documentElement.style.cursor = state.textInspectorMode ? "crosshair" : "";
+
+          if (!state.textInspectorMode) {
+            clearTextInspectorSelection(true);
+            return;
+          }
+
+          scheduleMeasure();
+        }
+
+        function handleTextInspectorPointerMove(event) {
+          if (!state.textInspectorMode || state.semanticBlockEditMode || state.isSemanticBlockPointerActive) {
+            return;
+          }
+
+          const element = getInspectableTextElementAtPoint(event.clientX, event.clientY, event.target);
+          const textUnit = element ? buildTextUnitPayload(element) : null;
+          const nextId = textUnit?.id || "";
+
+          if ((state.hoveredTextUnit?.id || "") === nextId) {
+            return;
+          }
+
+          state.hoveredTextUnit = textUnit;
+          scheduleMeasure();
+        }
+
+        function handleTextInspectorClick(event) {
+          if (!state.textInspectorMode || state.semanticBlockEditMode) {
+            return;
+          }
+
+          const element = getInspectableTextElementAtPoint(event.clientX, event.clientY, event.target);
+
+          if (!element) {
+            clearTextInspectorSelection(true);
+            return;
+          }
+
+          const textUnit = buildTextUnitPayload(element);
+
+          if (!textUnit) {
+            clearTextInspectorSelection(true);
+            return;
+          }
+
+          event.preventDefault();
+          event.stopPropagation();
+
+          if (typeof event.stopImmediatePropagation === "function") {
+            event.stopImmediatePropagation();
+          }
+
+          state.selectedTextUnit = textUnit;
+          state.hoveredTextUnit = textUnit;
+          postTextInspectorSelection(textUnit);
+          scheduleMeasure();
+        }
+
+        function handleTextInspectorPointerDown(event) {
+          if (state.semanticBlockEditMode) {
+            if (event.target instanceof Element && event.target.closest("#" + layerId)) {
+              return;
+            }
+
+            const element = getInspectableTextElementAtPoint(event.clientX, event.clientY, event.target);
+            const textUnit = element ? buildTextUnitPayload(element) : null;
+
+            if (!textUnit) return;
+
+            event.preventDefault();
+            event.stopPropagation();
+            if (typeof event.stopImmediatePropagation === "function") event.stopImmediatePropagation();
+
+            toggleTextUnitInSelectedSemanticBlock(textUnit, state.latestTargetRects || new Map());
+            return;
+          }
+
+          if (!state.textInspectorMode) {
+            return;
+          }
+
+          handleTextInspectorClick(event);
+        }
+
         function restoreAppliedSection(sectionId, record) {
           const element = record?.element;
 
@@ -713,10 +1381,18 @@ function buildPreviewBridgeScript() {
             return;
           }
 
-          writeElementText(element, record.originalText || "");
+          // Do not overwrite a legitimate runtime update that happened after
+          // the draft patch. Restore only the exact value written by us.
+          if (readElementText(element) === record.lastAppliedText) {
+            writeElementText(element, record.originalText || "");
+          }
 
           if (element instanceof HTMLElement) {
-            delete element.dataset.seoModeDraft;
+            if (record.originalDraftMarker == null) {
+              delete element.dataset.seoModeDraft;
+            } else {
+              element.dataset.seoModeDraft = record.originalDraftMarker;
+            }
           }
 
           appliedSectionTexts.delete(sectionId);
@@ -735,34 +1411,70 @@ function buildPreviewBridgeScript() {
             }
           }
 
+          const candidatesBySection = new Map();
+
           for (const target of state.targets) {
             const sectionId = target.sectionId || "";
             const nextText = state.sectionTexts[sectionId];
 
-            if (typeof nextText !== "string") {
+            if (!sectionId || typeof nextText !== "string" || target.preferPageStart) {
               continue;
             }
 
             const element = getTargetElement(target);
 
-            if (!element) {
+            if (
+              !element ||
+              !isSafePreviewPatchElement(element) ||
+              hasPresentedTextCompanion(element)
+            ) {
               continue;
             }
 
-            if (!isSafePreviewPatchElement(element)) {
+            const sectionCandidates = candidatesBySection.get(sectionId) || [];
+            if (!sectionCandidates.includes(element)) sectionCandidates.push(element);
+            candidatesBySection.set(sectionId, sectionCandidates);
+          }
+
+          const elementOwners = new Map();
+
+          for (const [sectionId, candidates] of candidatesBySection.entries()) {
+            if (candidates.length !== 1) continue;
+            const owners = elementOwners.get(candidates[0]) || new Set();
+            owners.add(sectionId);
+            elementOwners.set(candidates[0], owners);
+          }
+
+          for (const sectionId of nextSectionIds) {
+            const candidates = candidatesBySection.get(sectionId) || [];
+            const element = candidates.length === 1 ? candidates[0] : null;
+            const nextText = state.sectionTexts[sectionId];
+            const owners = element ? elementOwners.get(element) : null;
+
+            // One draft field must resolve to exactly one live element, and
+            // one element must never receive competing section values.
+            if (!element || owners?.size !== 1 || typeof nextText !== "string") {
+              const staleApplied = appliedSectionTexts.get(sectionId);
+              if (staleApplied) restoreAppliedSection(sectionId, staleApplied);
               continue;
             }
 
-            const applied = appliedSectionTexts.get(sectionId);
+            let applied = appliedSectionTexts.get(sectionId);
 
             if (!applied || applied.element !== element) {
-              appliedSectionTexts.set(sectionId, {
+              if (applied) restoreAppliedSection(sectionId, applied);
+
+              applied = {
                 element,
+                lastAppliedText: null,
+                originalDraftMarker: element instanceof HTMLElement ? element.dataset.seoModeDraft ?? null : null,
                 originalText: readElementText(element) || ""
-              });
+              };
+              appliedSectionTexts.set(sectionId, applied);
             }
 
             writeElementText(element, nextText);
+            applied.lastAppliedText = nextText;
 
             if (element instanceof HTMLElement) {
               element.dataset.seoModeDraft = "true";
@@ -837,6 +1549,8 @@ function buildPreviewBridgeScript() {
                 return [{
                   id: typeof entity.id === "string" && entity.id.trim() ? entity.id.trim() : selector,
                   kind: typeof entity.kind === "string" && entity.kind.trim() ? entity.kind.trim() : "element",
+                  pageId: typeof entity.pageId === "string" && entity.pageId.trim() ? entity.pageId.trim() : "",
+                  scopeId: typeof entity.scopeId === "string" && entity.scopeId.trim() ? entity.scopeId.trim() : "",
                   selector,
                   selectorIndex: Number.isInteger(entity.selectorIndex) && entity.selectorIndex >= 0 ? entity.selectorIndex : 0,
                   text: typeof entity.text === "string" && entity.text.trim() ? entity.text.trim().slice(0, 500) : ""
@@ -909,6 +1623,8 @@ function buildPreviewBridgeScript() {
               text: entity.text || ""
             },
             id: "captured:" + entity.selector + ":" + (entity.selectorIndex || 0),
+            pageId: entity.pageId || "",
+            scopeId: entity.scopeId || "",
             selector: entity.selector,
             selectorIndex: entity.selectorIndex || 0,
             source: "captured_dom",
@@ -924,6 +1640,8 @@ function buildPreviewBridgeScript() {
           return {
             id: anchor.id || "captured:" + anchor.selector,
             kind: anchor.entityType || "element",
+            pageId: anchor.pageId || "",
+            scopeId: anchor.scopeId || "",
             selector: anchor.selector,
             selectorIndex: anchor.selectorIndex || 0,
             text: anchor.text || anchor.fingerprint?.text || ""
@@ -965,6 +1683,7 @@ function buildPreviewBridgeScript() {
             documentWidth: Number.isFinite(Number(geometry.documentWidth)) ? Number(geometry.documentWidth) : null,
             height: Math.max(2, height),
             left: Math.max(0, left),
+            mode: geometry.mode === "manual" ? "manual" : geometry.mode === "anchor" ? "anchor" : null,
             offsets: offsets && Object.values(offsets).every(Number.isFinite) ? offsets : null,
             top: Math.max(0, top),
             width: Math.max(2, width)
@@ -1017,6 +1736,17 @@ function buildPreviewBridgeScript() {
           return path.length > 0 ? path.join(" > ") : "";
         }
 
+        function getElementSelectorIndex(element, selector) {
+          if (!(element instanceof Element) || !selector) return 0;
+
+          try {
+            const index = Array.from(document.querySelectorAll(selector)).indexOf(element);
+            return index >= 0 ? index : 0;
+          } catch {
+            return 0;
+          }
+        }
+
         function normalizeSemanticBlockBox(box, index) {
           if (!box || typeof box !== "object") return null;
 
@@ -1066,22 +1796,19 @@ function buildPreviewBridgeScript() {
         const carouselLikeSemanticPattern = new RegExp(${JSON.stringify(CAROUSEL_LIKE_SEMANTIC_PATTERN_SOURCE)}, "iu");
 
         function getCarouselManualBoxBase(box) {
-          const visualIdMatch = /^(.*):visual-\d+$/i.exec(box.id || "");
-          const numberedTitleMatch = /^(.*?)(?:\s+|[-_#])\d+$/i.exec(box.title || "");
+          const visualIdMatch = /^(.*):visual-\\d+$/i.exec(box.id || "");
+          const numberedTitleMatch = /^(.*?)(?:\\s+|[-_#])\\d+$/i.exec(box.title || "");
           const baseTitle = (numberedTitleMatch?.[1] || box.title || "").trim();
-          const hasGeometry = Boolean(box.geometry);
           const searchableValue = ((visualIdMatch?.[1] || "") + " " + baseTitle + " " + (box.id || "") + " " + (box.title || "")).toLocaleLowerCase("ru-RU");
 
-          if (!carouselLikeSemanticPattern.test(searchableValue)) {
-            return null;
-          }
-
-          if (!visualIdMatch && numberedTitleMatch && !hasGeometry) {
+          // Only a stable semantic id may collapse visual projections. Title,
+          // row and geometry are diagnostics and never define membership.
+          if (!visualIdMatch || !carouselLikeSemanticPattern.test(searchableValue)) {
             return null;
           }
 
           return {
-            id: visualIdMatch?.[1] || "manual-carousel:" + baseTitle.toLocaleLowerCase("ru-RU").replace(/[^a-zа-яё0-9:_-]+/giu, "-"),
+            id: visualIdMatch[1],
             title: baseTitle || box.title || "Слайдер"
           };
         }
@@ -1117,8 +1844,7 @@ function buildPreviewBridgeScript() {
               continue;
             }
 
-            const band = Math.round(box.top / Math.max(220, box.height || 220));
-            const key = base.id.startsWith("manual-carousel:") ? base.id + ":band-" + band : base.id;
+            const key = base.id;
             const existing = mergedByKey.get(key);
 
             if (!existing) {
@@ -1153,10 +1879,6 @@ function buildPreviewBridgeScript() {
         }
 
         function isCarouselLikeTargetGroup(group, target) {
-          if (group?.visualGroupMode === "single" || group?.singleVisualBlock === true) {
-            return true;
-          }
-
           const value = [
             group?.id,
             group?.source,
@@ -1170,6 +1892,11 @@ function buildPreviewBridgeScript() {
             .join(" ")
             .toLocaleLowerCase("ru-RU");
 
+          // singleVisualBlock is a grouping hint, not permission to bridge
+          // remote occurrences across an entire page. Only true carousel /
+          // gallery structures may stay a single projected visual block;
+          // ordinary hero, form and content groups are clustered by their
+          // actual on-screen proximity below.
           return carouselLikeSemanticPattern.test(value);
         }
 
@@ -1267,6 +1994,10 @@ function buildPreviewBridgeScript() {
         }
 
         function getReadableElementText(element) {
+          if (element.getAttribute?.("aria-hidden") === "true" && element.getAttribute("aria-label")) {
+            return element.getAttribute("aria-label") || "";
+          }
+
           if (element instanceof HTMLImageElement) {
             return element.alt || element.title || element.getAttribute("aria-label") || element.currentSrc || element.src || "";
           }
@@ -1346,7 +2077,7 @@ function buildPreviewBridgeScript() {
             pageId: input?.pageId || state.activeScopePageId || "",
             scopeId: input?.scopeId || state.activeScopeId || "",
             selector,
-            selectorIndex: 0,
+            selectorIndex: getElementSelectorIndex(element, selector),
             source: input?.source || "captured_dom",
             targetId: input?.targetId || "",
             text: getReadableElementText(element).replace(/\\s+/g, " ").trim().slice(0, 500)
@@ -1488,7 +2219,7 @@ function buildPreviewBridgeScript() {
               kind: getSemanticContainerKind(candidate.element),
               selector,
               selectorIndex: 0,
-              text: getReadableElementText(candidate.element).replace(/\s+/g, " ").trim().slice(0, 500)
+              text: getReadableElementText(candidate.element).replace(/\\s+/g, " ").trim().slice(0, 500)
             };
           });
         }
@@ -1539,7 +2270,7 @@ function buildPreviewBridgeScript() {
           };
         }
 
-        function captureSemanticBlockEntities(box, targetRects, targetIds) {
+        function captureSemanticBlockEntities(box, targetRects, targetIds, includeExisting = true) {
           const knownTargetIds = new Set(targetIds);
           const knownTargetElements = new Set(
             Array.from(targetRects.values())
@@ -1547,7 +2278,7 @@ function buildPreviewBridgeScript() {
               .map((entry) => getTargetElement(entry.target))
               .filter(Boolean)
           );
-          const existingEntities = normalizeCapturedEntities(box.capturedEntities);
+          const existingEntities = includeExisting ? normalizeCapturedEntities(box.capturedEntities) : [];
           const existingKeys = new Set(existingEntities.map((entity) => entity.selector + "::" + entity.selectorIndex));
           const candidates = Array.from(document.querySelectorAll("h1,h2,h3,h4,h5,h6,p,a,span,strong,em,small,li,button,div,img,picture,video,canvas,svg,input,textarea"))
             .filter(isSemanticCaptureCandidate)
@@ -1566,7 +2297,7 @@ function buildPreviewBridgeScript() {
 
           const captured = [
             ...existingEntities,
-            ...captureSemanticBlockContainerEntities(box, knownTargetElements, existingKeys)
+            ...(includeExisting ? captureSemanticBlockContainerEntities(box, knownTargetElements, existingKeys) : [])
           ];
 
           for (const candidate of candidates) {
@@ -1583,7 +2314,7 @@ function buildPreviewBridgeScript() {
               kind: getSemanticEntityKind(candidate.element),
               selector,
               selectorIndex,
-              text: getReadableElementText(candidate.element).replace(/\s+/g, " ").trim().slice(0, 500)
+              text: getReadableElementText(candidate.element).replace(/\\s+/g, " ").trim().slice(0, 500)
             });
           }
 
@@ -1642,15 +2373,15 @@ function buildPreviewBridgeScript() {
           });
         }
 
-        function getSemanticBlockAnchors(box, targetRects, targetIds) {
-          const capturedEntities = captureSemanticBlockEntities(box, targetRects, targetIds);
+        function getSemanticBlockAnchors(box, targetRects, targetIds, includeExisting = true) {
+          const capturedEntities = captureSemanticBlockEntities(box, targetRects, targetIds, includeExisting);
           const anchors = normalizeSemanticBlockAnchors([
-            ...(box.anchors || []),
+            ...(includeExisting ? (box.anchors || []) : []),
             ...targetIds.map((targetId) => getTargetAnchor(targetId, targetRects)).filter(Boolean),
             ...capturedEntities.map(getAnchorFromCapturedEntity)
           ]);
 
-          return anchors.length > 0 ? anchors : [getManualScopeAnchor(box)];
+          return anchors.length > 0 ? anchors : includeExisting ? [getManualScopeAnchor(box)] : [];
         }
 
         function isContainerLikeAnchor(anchor) {
@@ -1669,12 +2400,55 @@ function buildPreviewBridgeScript() {
           return !(anchorIsMuchLargerThanManualBox && anchorOnlyCoversManualBox);
         }
 
-        function getAnchorEntry(anchor, order = 0) {
-          if (!anchor?.selector) {
-            return null;
+        function resolveSemanticMemberElement(anchor) {
+          if (!anchor) return null;
+
+          const target = anchor.targetId ? state.targets.find((candidate) => candidate.id === anchor.targetId) : null;
+          const targetElement = target
+            ? getTargetElement(target, { clipViewport: false, clipOverflow: false })
+            : null;
+
+          if (targetElement && isVisibleElement(targetElement)) {
+            return targetElement;
           }
 
-          const element = getElementForSelector(anchor.selector, anchor.selectorIndex);
+          const selectedElement = anchor.selector
+            ? getElementForSelector(anchor.selector, anchor.selectorIndex)
+            : null;
+
+          if (selectedElement && isVisibleElement(selectedElement)) {
+            return selectedElement;
+          }
+
+          const fingerprintText = normalizeBridgeText(anchor.fingerprint?.text || anchor.text || "");
+          if (fingerprintText.length < 2) return null;
+
+          const fingerprintTag = String(anchor.fingerprint?.tagName || "").toLowerCase();
+          const candidates = getTextCandidateElements(document.body, { clipViewport: false, clipOverflow: false })
+            .filter((candidate) => {
+              if (fingerprintTag && candidate.element.tagName.toLowerCase() !== fingerprintTag) return false;
+              return candidate.text === fingerprintText || candidate.text.includes(fingerprintText) || fingerprintText.includes(candidate.text);
+            })
+            .sort((first, second) => {
+              const firstDelta = Math.abs(first.text.length - fingerprintText.length);
+              const secondDelta = Math.abs(second.text.length - fingerprintText.length);
+              if (firstDelta !== secondDelta) return firstDelta - secondDelta;
+
+              const firstArea = Math.max(1, first.rect.width * first.rect.height);
+              const secondArea = Math.max(1, second.rect.width * second.rect.height);
+              return firstArea - secondArea;
+            });
+
+          return candidates[0]?.element || null;
+        }
+
+        function getAnchorEntry(anchor, order = 0) {
+          if (!anchor?.selector) {
+            const target = anchor?.targetId ? state.targets.find((candidate) => candidate.id === anchor.targetId) : null;
+            if (!target) return null;
+          }
+
+          const element = resolveSemanticMemberElement(anchor);
           const rect = element ? getVisibleRect(element, { clipViewport: false, clipOverflow: false }) : null;
 
           if (!element || !rect) {
@@ -1695,6 +2469,15 @@ function buildPreviewBridgeScript() {
           const targetEntries = targetIds
             .map((targetId) => targetRects.get(targetId))
             .filter(isSemanticBoxEntry)
+            .filter((entry) => {
+              if (!referenceBox) return true;
+
+              const fit = getRectBoxFit(entry, referenceBox);
+              const entryIsMuchLargerThanManualBox = fit.sizeRatio > 5.5;
+              const entryOnlyCoversManualBox = fit.boxCoverage >= 0.62 && fit.rectCoverage < 0.24;
+
+              return !(entryIsMuchLargerThanManualBox && entryOnlyCoversManualBox);
+            })
             .sort((first, second) => first.top - second.top || first.left - second.left);
           const anchors = normalizeSemanticBlockAnchors([
             ...(Array.isArray(anchorsOrCapturedEntities) ? anchorsOrCapturedEntities : []),
@@ -1708,13 +2491,14 @@ function buildPreviewBridgeScript() {
           return [...targetEntries, ...capturedEntries];
         }
 
-        function getSemanticBlockGeometry(box, entries) {
+        function getSemanticBlockGeometry(box, entries, mode = box.geometry?.mode || "anchor") {
           const documentSize = getDocumentSize();
           const geometry = {
             documentHeight: documentSize.height,
             documentWidth: documentSize.width,
             height: box.height,
             left: box.left,
+            mode,
             top: box.top,
             width: box.width
           };
@@ -1749,37 +2533,54 @@ function buildPreviewBridgeScript() {
 
           state.lastSemanticBlockLocalEditAt = Date.now();
           state.lastSemanticBlockLocalEditWorkspaceKey = state.workspaceKey;
+          state.lastSemanticBlockLocalEditSessionKey = state.editorSessionKey;
 
-          const boxes = state.manualSemanticBlockBoxes
-            .map(resolveManualGeometryBox)
-            .map((box) => {
-              const targetIds = getBoxTargetIds(box, targetRects);
-              const anchors = getSemanticBlockAnchors(box, targetRects, targetIds);
-              const capturedEntities = anchors.map(getCapturedEntityFromAnchor).filter(Boolean);
-              const anchorEntries = getAnchorEntries(targetIds, anchors, targetRects, box);
-              const targetBound = targetIds.length > 0 || anchors.some((anchor) => anchor.selector);
+          const boxes = state.manualSemanticBlockBoxes.map((box) => {
+            const targetIds = Array.from(new Set((box.targetIds || []).filter(Boolean)));
+            const capturedEntities = normalizeCapturedEntities(box.capturedEntities);
+            const anchors = normalizeSemanticBlockAnchors([
+              ...(box.anchors || []),
+              ...capturedEntities.map(getAnchorFromCapturedEntity)
+            ]);
+            const memberEntries = getSemanticBlockMemberEntries(
+              { ...box, anchors, capturedEntities, targetIds },
+              targetRects
+            );
+            const bounds = memberEntries.length > 0 ? getEntriesBounds(memberEntries) : null;
+            const geometry = bounds
+              ? {
+                  documentHeight: getDocumentSize().height,
+                  documentWidth: getDocumentSize().width,
+                  height: bounds.height,
+                  left: bounds.left,
+                  top: bounds.top,
+                  width: bounds.width
+                }
+              : undefined;
 
-              return {
-                anchors,
-                capturedEntities,
-                geometry: getSemanticBlockGeometry(box, anchorEntries),
-                height: box.height,
-                id: box.id,
-                left: box.left,
-                targetBound,
-                targetIds,
-                title: box.title,
-                top: box.top,
-                width: box.width
-              };
-            });
+            return {
+              anchors,
+              capturedEntities,
+              geometry,
+              height: bounds?.height ?? box.height,
+              id: box.id,
+              left: bounds?.left ?? box.left,
+              targetBound: targetIds.length > 0 || anchors.length > 0 || capturedEntities.length > 0,
+              targetIds,
+              title: box.title,
+              top: bounds?.top ?? box.top,
+              width: bounds?.width ?? box.width
+            };
+          });
 
-          window.parent?.postMessage({
+          postBridgeMessage({
             type: "seo-mode:semantic-block-draft",
             workspaceKey: state.workspaceKey,
+            editorSessionKey: state.editorSessionKey,
             hasManualSemanticBlockSet: state.hasManualSemanticBlockSet,
+            selectedBlockId: state.selectedSemanticBlockId,
             boxes
-          }, "*");
+          });
         }
 
         function getEntriesBounds(entries) {
@@ -1815,18 +2616,22 @@ function buildPreviewBridgeScript() {
 
           const bounds = getEntriesBounds(entries);
           const padding = 12;
-          const offsets = box.geometry?.offsets;
-          const nextLeft = offsets ? bounds.left + clampSemanticBlockOffset(offsets.left, bounds.width) : bounds.left - padding;
-          const nextTop = offsets ? bounds.top + clampSemanticBlockOffset(offsets.top, bounds.height) : bounds.top - padding;
-          const nextRight = offsets ? bounds.right + clampSemanticBlockOffset(offsets.right, bounds.width) : bounds.right + padding;
-          const nextBottom = offsets ? bounds.bottom + clampSemanticBlockOffset(offsets.bottom, bounds.height) : bounds.bottom + padding;
+          const nextLeft = bounds.left - padding;
+          const nextTop = bounds.top - padding;
+          const nextRight = bounds.right + padding;
+          const nextBottom = bounds.bottom + padding;
+          const documentSize = getDocumentSize();
+          const clampedLeft = Math.max(4, nextLeft);
+          const clampedTop = Math.max(4, nextTop);
+          const clampedRight = Math.max(clampedLeft + 2, Math.min(documentSize.width - 4, nextRight));
+          const clampedBottom = Math.max(clampedTop + 2, Math.min(documentSize.height - 4, nextBottom));
 
           return {
             ...box,
-            left: Math.max(4, nextLeft),
-            top: Math.max(4, nextTop),
-            width: Math.max(80, nextRight - nextLeft),
-            height: Math.max(56, nextBottom - nextTop),
+            left: clampedLeft,
+            top: clampedTop,
+            width: Math.max(80, clampedRight - clampedLeft),
+            height: Math.max(56, clampedBottom - clampedTop),
             targetIds: Array.from(new Set([...(box.targetIds || []), ...entries.map((entry) => entry.target?.id).filter(Boolean)]))
           };
         }
@@ -1866,7 +2671,20 @@ function buildPreviewBridgeScript() {
             return box;
           }
 
-          const entries = getAnchorEntries(box.targetIds, [...(box.anchors || []), ...(box.capturedEntities || [])], targetRects, box)
+          // Old workspaces may contain a hand-drawn rectangle plus anchors
+          // captured by the previous implementation. Use that rectangle only
+          // once as a migration aperture: reject page/section-sized targets
+          // that merely covered it. Anchor-mode blocks never depend on stored
+          // viewport pixels and are projected from all current members.
+          const migrationReferenceBox = box.geometry?.mode === "manual"
+            ? resolveGeometryFallbackBox(box)
+            : null;
+          const entries = getAnchorEntries(
+            box.targetIds,
+            [...(box.anchors || []), ...(box.capturedEntities || [])],
+            targetRects,
+            migrationReferenceBox
+          )
             .sort((first, second) => first.top - second.top || first.left - second.left);
 
           return createSemanticBlockBoxFromEntries(box, entries) || resolveGeometryFallbackBox(box);
@@ -1881,6 +2699,20 @@ function buildPreviewBridgeScript() {
             return false;
           }
 
+          // A text/source target may legally resolve to a layout wrapper. It
+          // is still not a valid visual member when that wrapper spans most of
+          // the document: admitting it turns every descendant composition
+          // into one page-sized frame. Such targets remain available to the
+          // source model, but the visual block layer must use their concrete
+          // descendant/captured anchors instead.
+          const documentSize = getDocumentSize();
+          const maxMemberHeight = Math.max(window.innerHeight * 2.2, documentSize.height * 0.48);
+          const absoluteViewportLimit = Math.max(1800, window.innerHeight * 6);
+
+          if (entry.height > maxMemberHeight || entry.height > absoluteViewportLimit) {
+            return false;
+          }
+
           return entry.width > 0 && entry.height > 0;
         }
 
@@ -1897,6 +2729,13 @@ function buildPreviewBridgeScript() {
           const sameColumn = horizontalOverlap / minWidth >= 0.32 && verticalGap <= Math.max(96, window.innerHeight * 0.13);
           const sameRow = verticalOverlap / minHeight >= 0.32 && horizontalGap <= Math.max(140, window.innerWidth * 0.12);
           const closeStack = horizontalGap <= Math.max(56, window.innerWidth * 0.045) && verticalGap <= Math.max(72, window.innerHeight * 0.08);
+          const projectedHeight = Math.max(bounds.bottom, entryBottom) - Math.min(bounds.top, entry.top);
+          const tallestPart = Math.max(bounds.height, entry.height);
+          const localCompositionHeight = Math.max(window.innerHeight * 1.35, tallestPart * 2.8 + 96);
+
+          if (!sameRow && projectedHeight > localCompositionHeight) {
+            return false;
+          }
 
           return sameColumn || sameRow || closeStack;
         }
@@ -1928,13 +2767,13 @@ function buildPreviewBridgeScript() {
 
         function getAutoSemanticContainerTitle(element, index) {
           const heading = element.querySelector?.("h1,h2,h3,h4,h5,h6");
-          const headingText = heading ? getReadableElementText(heading).replace(/\s+/g, " ").trim() : "";
+          const headingText = heading ? getReadableElementText(heading).replace(/\\s+/g, " ").trim() : "";
           const label = element.getAttribute?.("aria-label") || element.getAttribute?.("data-label") || "";
 
           if (headingText) return headingText.slice(0, 80);
           if (label) return label.slice(0, 80);
 
-          const text = getReadableElementText(element).replace(/\s+/g, " ").trim();
+          const text = getReadableElementText(element).replace(/\\s+/g, " ").trim();
           return text ? text.slice(0, 80) : "Контейнер " + index;
         }
 
@@ -2110,7 +2949,7 @@ function buildPreviewBridgeScript() {
               });
               const baseBox = {
                 anchors: anchor ? [anchor] : [],
-                id: ("semantic-auto:" + (selector || index)).replace(/[^a-z0-9:_-]+/gi, "-").slice(0, 120),
+                id: ("semantic-auto:" + (selector || index)).replace(/[^\\p{L}\\p{N}:_-]+/gu, "-").slice(0, 120),
                 targetBound: true,
                 targetIds: [],
                 title: getAutoSemanticContainerTitle(candidate.element, index + 1)
@@ -2151,8 +2990,8 @@ function buildPreviewBridgeScript() {
               return visualGroups.map((entries, visualIndex) => {
               const visualSuffix = visualGroups.length > 1 ? ":visual-" + (visualIndex + 1) : "";
               const baseBox = {
-                id: (group.id + visualSuffix).replace(/[^a-z0-9:_-]+/gi, "-").slice(0, 120) || "block-" + (groupIndex + 1),
-                targetBound: false,
+                id: (group.id + visualSuffix).replace(/[^\\p{L}\\p{N}:_-]+/gu, "-").slice(0, 120) || "block-" + (groupIndex + 1),
+                targetBound: true,
                 title: visualGroups.length > 1 ? group.title + " " + (visualIndex + 1) : group.title
               };
 
@@ -2166,27 +3005,59 @@ function buildPreviewBridgeScript() {
           return [...targetBoxes, ...autoTextBoxes].slice(0, 80);
         }
 
-        function getEditableSemanticBlockBoxes(targetRects) {
-          let sourceBoxes = state.hasManualSemanticBlockSet
-            ? state.manualSemanticBlockBoxes
-            : getDefaultSemanticBlockBoxes(targetRects);
-
-          if (state.hasManualSemanticBlockSet) {
-            const collapsedBoxes = collapseCarouselManualSemanticBlockBoxes(sourceBoxes);
-            const changed =
-              collapsedBoxes.length !== sourceBoxes.length ||
-              collapsedBoxes.some((box, index) => box.id !== sourceBoxes[index]?.id || box.title !== sourceBoxes[index]?.title);
-
-            if (changed) {
-              state.manualSemanticBlockBoxes = collapsedBoxes;
-              sourceBoxes = collapsedBoxes;
-            }
+        function isLegacyOversizedSemanticBlockBox(box) {
+          if (!box) {
+            return false;
           }
 
-          const boxes = sourceBoxes
-            .map((box) => state.hasManualSemanticBlockSet ? resolveManualGeometryBox(box) : resolveTargetBoundSemanticBlockBox(box, targetRects))
+          const documentSize = getDocumentSize();
+          const maxAutomaticHeight = Math.max(window.innerHeight * 2.2, documentSize.height * 0.48);
+          const absoluteViewportLimit = Math.max(1800, window.innerHeight * 6);
+
+          return box.height > maxAutomaticHeight || box.height > absoluteViewportLimit;
+        }
+
+        function migrateLegacyOversizedSemanticBlockBoxes(sourceBoxes, targetRects) {
+          const resolvedSourceBoxes = sourceBoxes
+            .map((box) => box.targetBound ? resolveTargetBoundSemanticBlockBox(box, targetRects) : resolveManualGeometryBox(box))
             .filter(Boolean);
 
+          if (!resolvedSourceBoxes.some(isLegacyOversizedSemanticBlockBox)) {
+            return { boxes: sourceBoxes, migrated: false };
+          }
+
+          const oversizedIds = new Set(
+            resolvedSourceBoxes
+              .filter(isLegacyOversizedSemanticBlockBox)
+              .map((box) => box.id)
+          );
+          const preservedBoxes = sourceBoxes.filter((box) => !oversizedIds.has(box.id));
+          const preservedIds = new Set(preservedBoxes.map((box) => box.id));
+          const regeneratedBoxes = getDefaultSemanticBlockBoxes(targetRects)
+            .filter((box) => !preservedIds.has(box.id));
+
+          return {
+            boxes: [...preservedBoxes, ...regeneratedBoxes].slice(0, 80),
+            migrated: true
+          };
+        }
+
+        function getEditableSemanticBlockBoxes(targetRects) {
+          // Stage 7 v2: the persisted object is a semantic membership group,
+          // not a viewport rectangle. Geometry is rendered from every member
+          // independently, so reflow and Desktop/Mobile never mutate meaning.
+          // Legacy geometry remains readable in storage, but it is not used as
+          // an editing or membership authority anymore.
+          const boxes = state.hasManualSemanticBlockSet
+            ? state.manualSemanticBlockBoxes.map((box) => ({
+                ...box,
+                targetBound:
+                  (box.targetIds || []).length > 0 ||
+                  (box.anchors || []).length > 0 ||
+                  (box.capturedEntities || []).length > 0
+              }))
+            : [];
+
           if (
             state.semanticBlockEditMode &&
             boxes.length > 0 &&
@@ -2220,7 +3091,9 @@ function buildPreviewBridgeScript() {
           }
 
           state.hasManualSemanticBlockSet = true;
-          state.manualSemanticBlockBoxes = getDefaultSemanticBlockBoxes(targetRects);
+          // Automatic layout suggestions stay suggestions. Entering the
+          // editor must never silently convert them into user-authored data.
+          state.manualSemanticBlockBoxes = [];
           return state.manualSemanticBlockBoxes;
         }
 
@@ -2233,7 +3106,7 @@ function buildPreviewBridgeScript() {
               return box;
             }
 
-            updatedBox = updater({ ...box, targetBound: false });
+            updatedBox = updater({ ...box });
             return updatedBox;
           });
 
@@ -2243,15 +3116,16 @@ function buildPreviewBridgeScript() {
         function addSemanticBlockBox(targetRects) {
           const boxes = promoteDefaultSemanticBlockBoxes(targetRects);
           const index = state.nextManualSemanticBlockIndex++;
-          const viewportLeft = window.scrollX + Math.max(24, window.innerWidth * 0.58 - 190);
-          const viewportTop = window.scrollY + Math.max(24, window.innerHeight * 0.38 - 90);
           const box = {
             id: "manual-added-" + Date.now() + "-" + index,
-            title: "Новый блок " + index,
-            left: Math.max(4, viewportLeft),
-            top: Math.max(4, viewportTop),
-            width: Math.max(260, Math.min(420, window.innerWidth * 0.28)),
-            height: 190,
+            title: "Семантическая группа " + index,
+            anchors: [],
+            capturedEntities: [],
+            left: window.scrollX + 20,
+            top: window.scrollY + 54,
+            width: 240,
+            height: 44,
+            targetBound: false,
             targetIds: []
           };
 
@@ -2281,6 +3155,225 @@ function buildPreviewBridgeScript() {
           deleteSemanticBlockBox(state.selectedSemanticBlockId, targetRects);
         }
 
+        function getSemanticTextUnitMemberKey(textUnit) {
+          if (!textUnit?.selector) return "";
+          return "member:" + (textUnit.targetId || "dom") + ":" + textUnit.selector + ":" + (textUnit.selectorIndex || 0);
+        }
+
+        function semanticBlockContainsTextUnit(box, textUnit) {
+          const memberKey = getSemanticTextUnitMemberKey(textUnit);
+          if (!memberKey) return false;
+
+          const hasExactMember = [...(box.anchors || []), ...(box.capturedEntities || [])].some((member) =>
+            member?.selector === textUnit.selector &&
+            Number(member?.selectorIndex || 0) === Number(textUnit.selectorIndex || 0)
+          );
+
+          if (hasExactMember) return true;
+
+          // Legacy target-only membership has no fragment anchor. Keep it
+          // selectable without collapsing new anchored fragments by target id.
+          return Boolean(
+            textUnit.targetId &&
+            (box.targetIds || []).includes(textUnit.targetId) &&
+            !(box.anchors || []).some((anchor) => anchor?.targetId === textUnit.targetId && anchor?.selector)
+          );
+        }
+
+        function removeTextUnitFromSemanticBlock(box, textUnit) {
+          const matchesMember = (member) =>
+            Boolean(
+              (
+                member?.selector === textUnit.selector &&
+                Number(member?.selectorIndex || 0) === Number(textUnit.selectorIndex || 0)
+              ) ||
+              (textUnit.targetId && member?.targetId === textUnit.targetId && !member?.selector)
+            );
+          const anchors = (box.anchors || []).filter((anchor) => !matchesMember(anchor));
+          const capturedEntities = (box.capturedEntities || []).filter((entity) => !matchesMember(entity));
+          const hasRemainingTargetMember = Boolean(
+            textUnit.targetId && anchors.some((anchor) => anchor?.targetId === textUnit.targetId)
+          );
+          const targetIds = (box.targetIds || []).filter(
+            (targetId) => targetId !== textUnit.targetId || hasRemainingTargetMember
+          );
+
+          return {
+            ...box,
+            anchors,
+            capturedEntities,
+            targetBound: targetIds.length > 0 || anchors.length > 0 || capturedEntities.length > 0,
+            targetIds
+          };
+        }
+
+        function getTextUnitSemanticAnchor(textUnit) {
+          const element = getTextUnitElement(textUnit);
+          if (!element) return null;
+
+          return getAnchorFromElement(element, {
+            entityType: textUnit.role || getSemanticEntityKind(element),
+            id: getSemanticTextUnitMemberKey(textUnit),
+            source: textUnit.targetId ? "workspace_target" : "captured_dom",
+            targetId: textUnit.targetId || ""
+          });
+        }
+
+        function ensureSelectedSemanticBlock(targetRects) {
+          const boxes = promoteDefaultSemanticBlockBoxes(targetRects);
+          const selected = boxes.find((box) => box.id === state.selectedSemanticBlockId);
+          if (selected) return selected;
+
+          const index = state.nextManualSemanticBlockIndex++;
+          const block = {
+            id: "manual-added-" + Date.now() + "-" + index,
+            title: "Семантическая группа " + index,
+            anchors: [],
+            capturedEntities: [],
+            left: window.scrollX + 20,
+            top: window.scrollY + 54,
+            width: 240,
+            height: 44,
+            targetBound: false,
+            targetIds: []
+          };
+
+          state.manualSemanticBlockBoxes = [...boxes, block];
+          state.selectedSemanticBlockId = block.id;
+          return block;
+        }
+
+        function toggleTextUnitInSelectedSemanticBlock(textUnit, targetRects) {
+          if (!textUnit) return;
+
+          const selected = ensureSelectedSemanticBlock(targetRects);
+          const wasSelected = semanticBlockContainsTextUnit(selected, textUnit);
+          const anchor = getTextUnitSemanticAnchor(textUnit);
+
+          state.manualSemanticBlockBoxes = state.manualSemanticBlockBoxes.map((box) => {
+            const withoutTextUnit = removeTextUnitFromSemanticBlock(box, textUnit);
+
+            if (box.id !== selected.id || wasSelected || !anchor) {
+              return withoutTextUnit;
+            }
+
+            const anchors = normalizeSemanticBlockAnchors([...(withoutTextUnit.anchors || []), anchor]);
+            const capturedEntities = textUnit.targetId
+              ? normalizeCapturedEntities(withoutTextUnit.capturedEntities || [])
+              : normalizeCapturedEntities([
+                  ...(withoutTextUnit.capturedEntities || []),
+                  getCapturedEntityFromAnchor(anchor)
+                ].filter(Boolean));
+            const targetIds = textUnit.targetId
+              ? Array.from(new Set([...(withoutTextUnit.targetIds || []), textUnit.targetId]))
+              : withoutTextUnit.targetIds || [];
+
+            return {
+              ...withoutTextUnit,
+              anchors,
+              capturedEntities,
+              targetBound: true,
+              targetIds
+            };
+          });
+
+          state.hasManualSemanticBlockSet = true;
+          state.selectedTextUnit = textUnit;
+          postSemanticBlockDraft(targetRects);
+          scheduleMeasure();
+        }
+
+        function getSemanticBlockMemberEntries(box, targetRects) {
+          const entries = [];
+          const entryKeys = new Set();
+          const anchors = normalizeSemanticBlockAnchors([
+            ...(box.anchors || []),
+            ...normalizeCapturedEntities(box.capturedEntities).map(getAnchorFromCapturedEntity)
+          ]);
+          const visuallyAnchoredTargetIds = new Set(
+            anchors.filter((anchor) => anchor.targetId && anchor.selector).map((anchor) => anchor.targetId)
+          );
+
+          function appendEntry(entry, key) {
+            if (!entry || !key || entryKeys.has(key) || entry.width < 2 || entry.height < 2) return;
+            entryKeys.add(key);
+            entries.push(entry);
+          }
+
+          for (const targetId of box.targetIds || []) {
+            if (visuallyAnchoredTargetIds.has(targetId)) continue;
+            appendEntry(targetRects.get(targetId), "target:" + targetId);
+          }
+
+          anchors.forEach((anchor, index) => {
+            const entry = getAnchorEntry(anchor, index);
+            const key = anchor.targetId
+              ? "target:" + anchor.targetId + ":" + (anchor.selector || anchor.id) + ":" + (anchor.selectorIndex || 0)
+              : "dom:" + (anchor.selector || anchor.id) + ":" + (anchor.selectorIndex || 0);
+            appendEntry(entry, key);
+          });
+
+          return entries.sort((first, second) => first.top - second.top || first.left - second.left);
+        }
+
+        function createAdaptiveSemanticBlockVisuals(box, targetRects) {
+          const isSelected = state.selectedSemanticBlockId === box.id;
+          const entries = getSemanticBlockMemberEntries(box, targetRects);
+          const visuals = [];
+          const color = isSelected ? "#5a7f2b" : "rgba(90,127,43,.72)";
+
+          entries.forEach((entry) => {
+            const outline = document.createElement("div");
+            outline.className = "seo-mode-semantic-member";
+            outline.dataset.semanticBlockId = box.id;
+            outline.style.position = "absolute";
+            outline.style.left = Math.max(0, entry.left - 5) + "px";
+            outline.style.top = Math.max(0, entry.top - 5) + "px";
+            outline.style.width = Math.max(2, entry.width + 10) + "px";
+            outline.style.height = Math.max(2, entry.height + 10) + "px";
+            outline.style.border = (isSelected ? "2px solid " : "1.5px solid ") + color;
+            outline.style.borderRadius = "10px";
+            outline.style.background = isSelected ? "rgba(90,127,43,.085)" : "rgba(90,127,43,.028)";
+            outline.style.boxShadow = isSelected ? "0 0 0 2px rgba(255,255,255,.68)" : "none";
+            outline.style.pointerEvents = "none";
+            outline.style.zIndex = isSelected ? "2147483638" : "2147483636";
+            visuals.push(outline);
+          });
+
+          const firstEntry = entries[0];
+          const label = document.createElement("button");
+          label.type = "button";
+          label.className = "seo-mode-semantic-group-label";
+          label.textContent = (box.title || "Семантическая группа") + " · " + entries.length;
+          label.style.position = "absolute";
+          label.style.left = Math.max(10, firstEntry?.left ?? window.scrollX + 18) + "px";
+          label.style.top = Math.max(10, (firstEntry?.top ?? window.scrollY + 58) - 30) + "px";
+          label.style.maxWidth = "320px";
+          label.style.overflow = "hidden";
+          label.style.padding = "6px 10px";
+          label.style.color = "#fff";
+          label.style.background = isSelected ? "#5a7f2b" : "rgba(64,83,42,.88)";
+          label.style.border = "1px solid rgba(255,255,255,.78)";
+          label.style.borderRadius = "999px";
+          label.style.boxShadow = "0 8px 22px rgba(24,32,29,.18)";
+          label.style.cursor = "pointer";
+          label.style.font = "750 11px/1 Inter, Arial, sans-serif";
+          label.style.textOverflow = "ellipsis";
+          label.style.whiteSpace = "nowrap";
+          label.style.zIndex = "2147483642";
+          label.addEventListener("pointerdown", (event) => {
+            event.preventDefault();
+            event.stopPropagation();
+            if (typeof event.stopImmediatePropagation === "function") event.stopImmediatePropagation();
+            state.selectedSemanticBlockId = box.id;
+            postSemanticBlockDraft(targetRects);
+            scheduleMeasure();
+          });
+          visuals.push(label);
+
+          return visuals;
+        }
+
         function getSemanticBlockAtPoint(clientX, clientY, targetRects) {
           const documentX = clientX + window.scrollX;
           const documentY = clientY + window.scrollY;
@@ -2314,11 +3407,11 @@ function buildPreviewBridgeScript() {
           element.style.top = box.top + "px";
           element.style.width = box.width + "px";
           element.style.height = box.height + "px";
-          element.style.border = isSelected ? "2px solid #ff2c92" : "1.5px solid rgba(232,45,134,.72)";
+          element.style.border = isSelected ? "2px solid #5a7f2b" : "1.5px solid rgba(90,127,43,.68)";
           element.style.borderRadius = "18px";
-          element.style.background = isSelected ? "rgba(232,45,134,.1)" : "rgba(232,45,134,.045)";
+          element.style.background = isSelected ? "rgba(90,127,43,.1)" : "rgba(90,127,43,.045)";
           element.style.boxShadow = isSelected
-            ? "0 0 0 1px rgba(255,255,255,.65), 0 0 24px rgba(232,45,134,.22)"
+            ? "0 0 0 1px rgba(255,255,255,.65), 0 0 24px rgba(90,127,43,.2)"
             : "0 0 0 1px rgba(255,255,255,.34)";
           element.style.zIndex = String(Math.max(1, 1000000 - Math.round(Math.min(box.width * box.height, 999000))) + (isSelected ? 1 : 0));
           element.style.pointerEvents = "auto";
@@ -2335,7 +3428,7 @@ function buildPreviewBridgeScript() {
           label.style.overflow = "hidden";
           label.style.padding = "4px 8px";
           label.style.color = "#fff";
-          label.style.background = "#e82d86";
+          label.style.background = "#5a7f2b";
           label.style.borderRadius = "999px";
           label.style.font = "700 11px/1 Inter, Arial, sans-serif";
           label.style.textOverflow = "ellipsis";
@@ -2356,10 +3449,10 @@ function buildPreviewBridgeScript() {
             deleteButton.style.placeItems = "center";
             deleteButton.style.padding = "0";
             deleteButton.style.color = "#fff";
-            deleteButton.style.background = "#e82d86";
+            deleteButton.style.background = "#a4332c";
             deleteButton.style.border = "1px solid rgba(255,255,255,.86)";
             deleteButton.style.borderRadius = "999px";
-            deleteButton.style.boxShadow = "0 6px 16px rgba(232,45,134,.28)";
+            deleteButton.style.boxShadow = "0 6px 16px rgba(164,51,44,.24)";
             deleteButton.style.cursor = "pointer";
             deleteButton.style.font = "800 14px/1 Inter, Arial, sans-serif";
             deleteButton.addEventListener("pointerdown", (event) => {
@@ -2468,10 +3561,23 @@ function buildPreviewBridgeScript() {
               window.removeEventListener("pointermove", onMove);
               window.removeEventListener("pointerup", onUp);
               window.removeEventListener("pointercancel", onUp);
+              const nextTargetIds = getBoxTargetIds(latestBox, targetRects);
+              const nextAnchors = getSemanticBlockAnchors(latestBox, targetRects, nextTargetIds, false);
+              const nextCapturedEntities = nextAnchors.map(getCapturedEntityFromAnchor).filter(Boolean);
+              const nextAnchorEntries = getAnchorEntries(nextTargetIds, nextAnchors, targetRects, latestBox);
+              const nextTargetBound = nextTargetIds.length > 0 || nextAnchors.some((anchor) => anchor.selector);
+              const anchoredBox = nextTargetBound
+                ? (createSemanticBlockBoxFromEntries(latestBox, nextAnchorEntries) || latestBox)
+                : latestBox;
+
               updateManualSemanticBlockBox(activeBox.id, (currentBox) => ({
                 ...currentBox,
-                ...latestBox,
-                targetBound: false
+                ...anchoredBox,
+                anchors: nextAnchors,
+                capturedEntities: nextCapturedEntities,
+                geometry: getSemanticBlockGeometry(anchoredBox, nextAnchorEntries, "anchor"),
+                targetBound: nextTargetBound,
+                targetIds: nextTargetIds
               }), targetRects);
               state.isSemanticBlockPointerActive = false;
               postSemanticBlockDraft(targetRects);
@@ -2529,43 +3635,27 @@ function buildPreviewBridgeScript() {
             return;
           }
 
-          seedSemanticBlockEditBoxes(targetRects);
           const boxes = getEditableSemanticBlockBoxes(targetRects);
-          const renderBoxes = [...boxes].sort((first, second) => {
-            const firstArea = Math.max(1, first.width * first.height);
-            const secondArea = Math.max(1, second.width * second.height);
-
-            if (Math.abs(secondArea - firstArea) > 1) {
-              return secondArea - firstArea;
+          for (const box of boxes) {
+            for (const visual of createAdaptiveSemanticBlockVisuals(box, targetRects)) {
+              layer.appendChild(visual);
             }
-
-            return first.top - second.top || first.left - second.left;
-          });
-
-          for (const box of renderBoxes) {
-            layer.appendChild(createSemanticBlockBox(box, targetRects));
           }
         }
 
         function commitSemanticBlockBoxes(targetRects) {
-          // Manual boxes only regroup existing editable targets; empty overlays must not become source structure.
+          // Commit explicit membership only. No rectangle intersection, auto
+          // fit or responsive reflow is allowed to change semantic meaning.
           const boxes = getEditableSemanticBlockBoxes(targetRects)
-            .map((box) => {
-              const targetIds = getBoxTargetIds(box, targetRects);
-              const anchors = getSemanticBlockAnchors(box, targetRects, targetIds);
-              const capturedEntities = anchors.map(getCapturedEntityFromAnchor).filter(Boolean);
-              const anchorEntries = getAnchorEntries(targetIds, anchors, targetRects, box);
-              const targetBound = targetIds.length > 0 || anchors.some((anchor) => anchor.selector);
-
-              return {
-                ...box,
-                anchors,
-                capturedEntities,
-                geometry: getSemanticBlockGeometry(box, anchorEntries),
-                targetBound,
-                targetIds
-              };
-            })
+            .map((box) => ({
+              ...box,
+              anchors: normalizeSemanticBlockAnchors([
+                ...(box.anchors || []),
+                ...normalizeCapturedEntities(box.capturedEntities).map(getAnchorFromCapturedEntity)
+              ]),
+              capturedEntities: normalizeCapturedEntities(box.capturedEntities),
+              targetIds: Array.from(new Set((box.targetIds || []).filter(Boolean)))
+            }))
             .filter((box) => box.targetIds.length > 0 || box.capturedEntities.length > 0 || box.anchors.length > 0);
 
           state.hasManualSemanticBlockSet = true;
@@ -2574,12 +3664,13 @@ function buildPreviewBridgeScript() {
           state.selectedSemanticBlockId = "";
           scheduleMeasure();
 
-          window.parent?.postMessage({
+          postBridgeMessage({
             type: "seo-mode:semantic-block-commit",
             workspaceKey: state.workspaceKey,
+            editorSessionKey: state.editorSessionKey,
             hasManualSemanticBlockSet: state.hasManualSemanticBlockSet,
             boxes
-          }, "*");
+          });
         }
 
         function activateTarget(target, event) {
@@ -2598,12 +3689,12 @@ function buildPreviewBridgeScript() {
 
           lastActivation = { id: target.id, at: now };
 
-          window.parent?.postMessage({
+          postBridgeMessage({
             type: "seo-mode:activate-target",
             workspaceKey: state.workspaceKey,
             targetId: target.id,
             sectionId: target.sectionId || ""
-          }, "*");
+          });
         }
 
         function createMarker(target, left, top) {
@@ -2678,7 +3769,7 @@ function buildPreviewBridgeScript() {
           return Array.from(document.querySelectorAll("header, main, section, article, footer"))
             .filter((element) => {
               const rect = element.getBoundingClientRect();
-              const text = getReadableElementText(element).replace(/\s+/g, " ").trim();
+              const text = getReadableElementText(element).replace(/\\s+/g, " ").trim();
 
               return rect.width > 0 && rect.height > 20 && (text.length > 0 || element.querySelector("img,video,canvas,svg,picture,input,textarea,button"));
             });
@@ -2775,31 +3866,6 @@ function buildPreviewBridgeScript() {
           return anchor;
         }
 
-        function isSafeDomIdFragment(value) {
-          return /^[A-Za-z][\\w:-]*$/.test(String(value || ""));
-        }
-
-        function getScopedAnchorFallbackElement(page) {
-          if (!page || page.kind !== "section" || !page.scopeId || !page.selector || !page.selector.startsWith("#")) {
-            return null;
-          }
-
-          const selectorIndex = Number.isInteger(page.selectorIndex) && page.selectorIndex >= 0 ? page.selectorIndex : 0;
-
-          if (selectorIndex <= 0) {
-            return null;
-          }
-
-          const sectionId = String(page.scopeId).replace(/^section:/, "");
-          const anchorId = page.selector.slice(1);
-
-          if (!isSafeDomIdFragment(sectionId) || !isSafeDomIdFragment(anchorId)) {
-            return null;
-          }
-
-          return document.getElementById(sectionId + "-" + anchorId);
-        }
-
         function getScopePageElementByOrder(order) {
           if (typeof order !== "number" || order < 0) {
             return null;
@@ -2809,12 +3875,6 @@ function buildPreviewBridgeScript() {
         }
 
         function getScopePageAnchorElement(page) {
-          const scopedAnchorElement = getScopedAnchorFallbackElement(page);
-
-          if (scopedAnchorElement) {
-            return scopedAnchorElement;
-          }
-
           const selectorElement = page.selector ? getElementForSelector(page.selector, page.selectorIndex) : null;
 
           if (selectorElement) {
@@ -3005,12 +4065,12 @@ function buildPreviewBridgeScript() {
           state.activeScopeId = bestPage.scopeId;
           state.activeScopePageId = bestPage.pageId;
           state.lastScopeReportAt = now;
-          window.parent?.postMessage({
+          postBridgeMessage({
             type: "seo-mode:active-scope-page",
             workspaceKey: state.workspaceKey,
             scopeId: bestPage.scopeId,
             pageId: bestPage.pageId
-          }, "*");
+          });
         }
 
         function reportPreviewPointerDown(event) {
@@ -3024,10 +4084,10 @@ function buildPreviewBridgeScript() {
             return;
           }
 
-          window.parent?.postMessage({
+          postBridgeMessage({
             type: "seo-mode:preview-pointerdown",
             workspaceKey: state.workspaceKey
-          }, "*");
+          });
         }
 
         function scheduleDynamicLayoutMeasure() {
@@ -3035,10 +4095,6 @@ function buildPreviewBridgeScript() {
             return;
           }
 
-          if (state.semanticBlockEditMode && state.hasManualSemanticBlockSet) {
-            return;
-          }
-
           window.clearTimeout(dynamicLayoutMeasureTimer);
           const now = Date.now();
           const delay = now - lastDynamicLayoutMeasureAt > 90 ? 0 : 90;
@@ -3063,12 +4119,14 @@ function buildPreviewBridgeScript() {
           window.cancelAnimationFrame(scrollReportFrame);
           scrollReportFrame = window.requestAnimationFrame(reportActiveScopePage);
 
-          if (state.semanticBlockEditMode) {
-            return;
-          }
-
           window.clearTimeout(scrollMeasureTimer);
-          scrollMeasureTimer = window.setTimeout(scheduleMeasure, 220);
+          // Nested carousel/overflow scrolling changes member coordinates
+          // without resizing the DOM. Keep adaptive outlines projected while
+          // editing; throttling avoids a full measure on every wheel event.
+          scrollMeasureTimer = window.setTimeout(
+            scheduleMeasure,
+            state.semanticBlockEditMode || state.textInspectorMode ? 72 : 180
+          );
         }
 
         function observeDynamicLayout() {
@@ -3094,6 +4152,12 @@ function buildPreviewBridgeScript() {
             childList: true,
             subtree: true
           });
+
+          if (!dynamicResizeObserver && typeof ResizeObserver === "function") {
+            dynamicResizeObserver = new ResizeObserver(scheduleDynamicLayoutMeasure);
+            dynamicResizeObserver.observe(document.documentElement);
+            dynamicResizeObserver.observe(document.body);
+          }
         }
 
         function measure() {
@@ -3328,10 +4392,19 @@ function buildPreviewBridgeScript() {
 
           state.latestTargetRects = targetRects;
           renderSemanticBlockBoxes(layer, targetRects);
+          renderTextInspectorHighlights(layer);
 
           reportActiveScopePage();
         }
 
+        function isSemanticEditorMessageForCurrentSession(data) {
+          if (data.editorSessionKey && state.editorSessionKey) {
+            return data.editorSessionKey === state.editorSessionKey;
+          }
+
+          return !data.workspaceKey || !state.workspaceKey || data.workspaceKey === state.workspaceKey;
+        }
+
         window.addEventListener("message", (event) => {
           const data = event.data;
 
@@ -3339,16 +4412,23 @@ function buildPreviewBridgeScript() {
             return;
           }
 
+          if (!isTrustedParentMessage(event)) return;
+
           const nextWorkspaceKey = data.workspaceKey || "";
-          const isSameWorkspaceKey = state.workspaceKey === nextWorkspaceKey;
+          const nextEditorSessionKey = data.editorSessionKey || nextWorkspaceKey;
+          const isSameEditorSession = state.editorSessionKey === nextEditorSessionKey;
           state.workspaceKey = nextWorkspaceKey;
+          state.editorSessionKey = nextEditorSessionKey;
           state.targets = Array.isArray(data.targets) ? data.targets : [];
           state.scopePages = Array.isArray(data.scopePages) ? data.scopePages : [];
           state.activeScopeId = data.activeScopeId || state.activeScopeId || "";
           state.activeScopePageId = data.activePageId || state.activeScopePageId || "";
+          if (typeof data.textInspectorMode === "boolean" && data.textInspectorMode !== state.textInspectorMode) {
+            setTextInspectorMode(data.textInspectorMode);
+          }
           if (!state.isSemanticBlockPointerActive) {
             const hasRecentLocalSemanticBlockEdit =
-              state.lastSemanticBlockLocalEditWorkspaceKey === (data.workspaceKey || "") &&
+              state.lastSemanticBlockLocalEditSessionKey === nextEditorSessionKey &&
               Date.now() - state.lastSemanticBlockLocalEditAt < 1500;
 
             if (typeof data.semanticBlockEditMode === "boolean" && !hasRecentLocalSemanticBlockEdit) {
@@ -3358,7 +4438,7 @@ function buildPreviewBridgeScript() {
                 : false;
               const shouldKeepLocalSemanticBlockSeed =
                 nextSemanticBlockEditMode &&
-                isSameWorkspaceKey &&
+                isSameEditorSession &&
                 state.semanticBlockEditMode &&
                 state.hasManualSemanticBlockSet &&
                 !nextHasManualSemanticBlockSet &&
@@ -3381,6 +4461,20 @@ function buildPreviewBridgeScript() {
           scheduleMeasure();
         });
 
+        window.addEventListener("message", (event) => {
+          const data = event.data;
+
+          if (!data || data.type !== "seo-mode:set-text-inspector-mode") {
+            return;
+          }
+
+          if (!isTrustedParentMessage(event)) return;
+
+          if (!isSemanticEditorMessageForCurrentSession(data)) return;
+
+          setTextInspectorMode(Boolean(data.enabled));
+        });
+
         window.addEventListener("message", (event) => {
           const data = event.data;
 
@@ -3388,9 +4482,9 @@ function buildPreviewBridgeScript() {
             return;
           }
 
-          if (data.workspaceKey && state.workspaceKey && data.workspaceKey !== state.workspaceKey) {
-            return;
-          }
+          if (!isTrustedParentMessage(event)) return;
+
+          if (!isSemanticEditorMessageForCurrentSession(data)) return;
 
           if (state.isSemanticBlockPointerActive) {
             return;
@@ -3428,9 +4522,9 @@ function buildPreviewBridgeScript() {
             return;
           }
 
-          if (data.workspaceKey && state.workspaceKey && data.workspaceKey !== state.workspaceKey) {
-            return;
-          }
+          if (!isTrustedParentMessage(event)) return;
+
+          if (!isSemanticEditorMessageForCurrentSession(data)) return;
 
           commitSemanticBlockBoxes(state.latestTargetRects || new Map());
         });
@@ -3442,9 +4536,9 @@ function buildPreviewBridgeScript() {
             return;
           }
 
-          if (data.workspaceKey && state.workspaceKey && data.workspaceKey !== state.workspaceKey) {
-            return;
-          }
+          if (!isTrustedParentMessage(event)) return;
+
+          if (!isSemanticEditorMessageForCurrentSession(data)) return;
 
           if (!state.semanticBlockEditMode) {
             return;
@@ -3453,6 +4547,27 @@ function buildPreviewBridgeScript() {
           addSemanticBlockBox(state.latestTargetRects || new Map());
         });
 
+        window.addEventListener("message", (event) => {
+          const data = event.data;
+
+          if (!data || data.type !== "seo-mode:add-text-unit-to-selected-semantic-block") {
+            return;
+          }
+
+          if (!isTrustedParentMessage(event)) return;
+          if (!isSemanticEditorMessageForCurrentSession(data)) return;
+          if (!state.semanticBlockEditMode || !data.textUnit?.selector) return;
+
+          const element = getElementForSelector(data.textUnit.selector, data.textUnit.selectorIndex);
+          const textUnit = element ? buildTextUnitPayload(element) : null;
+          if (!textUnit) return;
+
+          if (data.createNewBlock) {
+            addSemanticBlockBox(state.latestTargetRects || new Map());
+          }
+          toggleTextUnitInSelectedSemanticBlock(textUnit, state.latestTargetRects || new Map());
+        });
+
         window.addEventListener("message", (event) => {
           const data = event.data;
 
@@ -3460,9 +4575,9 @@ function buildPreviewBridgeScript() {
             return;
           }
 
-          if (data.workspaceKey && state.workspaceKey && data.workspaceKey !== state.workspaceKey) {
-            return;
-          }
+          if (!isTrustedParentMessage(event)) return;
+
+          if (!isSemanticEditorMessageForCurrentSession(data)) return;
 
           if (!state.semanticBlockEditMode) {
             return;
@@ -3471,6 +4586,27 @@ function buildPreviewBridgeScript() {
           deleteSelectedSemanticBlockBox(state.latestTargetRects || new Map());
         });
 
+        window.addEventListener("message", (event) => {
+          const data = event.data;
+
+          if (!data || data.type !== "seo-mode:rename-selected-semantic-block") {
+            return;
+          }
+
+          if (!isTrustedParentMessage(event)) return;
+          if (!isSemanticEditorMessageForCurrentSession(data)) return;
+          if (!state.semanticBlockEditMode || !state.selectedSemanticBlockId) return;
+
+          const title = typeof data.title === "string" ? data.title.replace(/\\s+/g, " ").trim().slice(0, 260) : "";
+          if (!title) return;
+
+          state.manualSemanticBlockBoxes = state.manualSemanticBlockBoxes.map((box) =>
+            box.id === state.selectedSemanticBlockId ? { ...box, title } : box
+          );
+          postSemanticBlockDraft(state.latestTargetRects || new Map());
+          scheduleMeasure();
+        });
+
         window.addEventListener("message", (event) => {
           const data = event.data;
 
@@ -3478,6 +4614,8 @@ function buildPreviewBridgeScript() {
             return;
           }
 
+          if (!isTrustedParentMessage(event)) return;
+
           if (data.workspaceKey && state.workspaceKey && data.workspaceKey !== state.workspaceKey) {
             return;
           }
@@ -3494,6 +4632,12 @@ function buildPreviewBridgeScript() {
         document.addEventListener("pointerup", scheduleDynamicLayoutMeasure, { capture: true, passive: true });
         document.addEventListener("transitionend", scheduleDynamicLayoutMeasure, { capture: true, passive: true });
         document.addEventListener("keydown", (event) => {
+          if (event.key === "Escape" && state.textInspectorMode && state.selectedTextUnit) {
+            event.preventDefault();
+            clearTextInspectorSelection(true);
+            return;
+          }
+
           if (!state.semanticBlockEditMode || !state.selectedSemanticBlockId) {
             return;
           }
@@ -3506,7 +4650,18 @@ function buildPreviewBridgeScript() {
           event.stopPropagation();
           deleteSelectedSemanticBlockBox(state.latestTargetRects || new Map());
         });
+        document.addEventListener("pointermove", handleTextInspectorPointerMove, { capture: true, passive: true });
+        document.addEventListener("pointerdown", handleTextInspectorPointerDown, { capture: true });
+        document.addEventListener("load", scheduleDynamicLayoutMeasure, { capture: true, passive: true });
         document.addEventListener("pointerdown", reportPreviewPointerDown, { capture: true, passive: true });
+        window.visualViewport?.addEventListener("resize", scheduleDynamicLayoutMeasure, { passive: true });
+        window.visualViewport?.addEventListener("scroll", scheduleScrollUpdate, { passive: true });
+
+        if (document.fonts) {
+          document.fonts.ready.then(scheduleDynamicLayoutMeasure).catch(() => undefined);
+          document.fonts.addEventListener?.("loadingdone", scheduleDynamicLayoutMeasure);
+        }
+
         window.addEventListener("load", () => {
           observeDynamicLayout();
           window.setTimeout(scheduleMeasure, 50);
@@ -3611,8 +4766,7 @@ function buildPreviewStabilityStyle() {
     <style id="seo-mode-preview-stability">
       /* SEO preview must expose the complete document immediately. Lazy layout primitives
          such as content-visibility:auto otherwise move the scroll boundary while auditing. */
-      .c-viz,
-      [style*="content-visibility"] {
+      :where(html, body, body *) {
         content-visibility: visible !important;
         contain-intrinsic-size: none !important;
       }
@@ -3647,11 +4801,11 @@ function rewriteHtml(
 
   if (/<head\b[^>]*>/i.test(withRootedAttributes)) {
     return withRootedAttributes
-      .replace(/<head\b[^>]*>/i, (headTag) => `${headTag}${baseTag}${stabilityStyle}`)
-      .replace(/<\/body>/i, `${bridgeScript}${focusScript}</body>`);
+      .replace(/<head\b[^>]*>/i, (headTag) => `${headTag}${baseTag}${stabilityStyle}${bridgeScript}`)
+      .replace(/<\/body>/i, `${focusScript}</body>`);
   }
 
-  return `<!doctype html><html><head>${baseTag}${stabilityStyle}</head><body>${withRootedAttributes}${bridgeScript}${focusScript}</body></html>`;
+  return `<!doctype html><html><head>${baseTag}${stabilityStyle}${bridgeScript}</head><body>${withRootedAttributes}${focusScript}</body></html>`;
 }
 
 function rewriteCss(css: string, resolvedPath: string, sourceConfig: Record<string, unknown>) {
diff --git a/seo_mode/seo_mode/server/src/preview/semanticBlockRules.ts b/seo_mode/seo_mode/server/src/preview/semanticBlockRules.ts
index d4e5d93..0ebcd41 100644
--- a/seo_mode/seo_mode/server/src/preview/semanticBlockRules.ts
+++ b/seo_mode/seo_mode/server/src/preview/semanticBlockRules.ts
@@ -43,7 +43,10 @@ export type SemanticBlockAnchorLike = {
 };
 
 export function normalizeSemanticBlockIdFragment(value: string) {
-  return value.replace(/[^a-zA-Z0-9а-яА-ЯёЁ._-]+/g, "-").replace(/^-+|-+$/g, "");
+  return value
+    .normalize("NFKC")
+    .replace(/[^\p{L}\p{N}._-]+/gu, "-")
+    .replace(/^-+|-+$/g, "");
 }
 
 export function isCarouselLikeSemanticValue(values: Array<string | null | undefined>) {
@@ -58,7 +61,6 @@ export function getCarouselManualBoxBase(box: Pick<SemanticBlockBoxLike, "id" |
   const visualIdMatch = /^(.*):visual-\d+$/i.exec(box.id || "");
   const numberedTitleMatch = /^(.*?)(?:\s+|[-_#])\d+$/i.exec(box.title || "");
   const baseTitle = (numberedTitleMatch?.[1] || box.title || "").trim();
-  const hasGeometry = Boolean("geometry" in box && box.geometry);
   const searchableValue = [
     visualIdMatch?.[1],
     baseTitle,
@@ -69,16 +71,14 @@ export function getCarouselManualBoxBase(box: Pick<SemanticBlockBoxLike, "id" |
     .join(" ")
     .toLocaleLowerCase("ru-RU");
 
-  if (!CAROUSEL_LIKE_SEMANTIC_PATTERN.test(searchableValue)) {
-    return null;
-  }
-
-  if (!visualIdMatch && numberedTitleMatch && !hasGeometry) {
+  // Geometry and numbered labels are presentation hints only. A stable
+  // :visual-N identity is the sole authority for collapsing projections.
+  if (!visualIdMatch || !CAROUSEL_LIKE_SEMANTIC_PATTERN.test(searchableValue)) {
     return null;
   }
 
   return {
-    id: visualIdMatch?.[1] || `manual-carousel:${normalizeSemanticBlockIdFragment(baseTitle).toLocaleLowerCase("ru-RU")}`,
+    id: visualIdMatch[1],
     title: baseTitle || box.title || "Слайдер"
   };
 }
@@ -136,8 +136,7 @@ export function collapseCarouselManualSemanticBlockBoxes<T extends SemanticBlock
       continue;
     }
 
-    const band = Math.round(box.top / Math.max(220, box.height || 220));
-    const key = base.id.startsWith("manual-carousel:") ? `${base.id}:band-${band}` : base.id;
+    const key = base.id;
     const existing = mergedByKey.get(key);
 
     if (!existing) {
diff --git a/seo_mode/seo_mode/server/src/projects/routes.ts b/seo_mode/seo_mode/server/src/projects/routes.ts
index 1369b0c..3ba0aaf 100644
--- a/seo_mode/seo_mode/server/src/projects/routes.ts
+++ b/seo_mode/seo_mode/server/src/projects/routes.ts
@@ -299,6 +299,11 @@ const updateContentFieldDraftSchema = z.object({
 const semanticBlockSourceSchema = z.enum(["auto", "manual", "source_object", "visual_section", "workspace_section"]);
 const semanticBlockJsonRecordSchema = z.record(z.string(), z.unknown());
 const semanticBlockSaveSchema = z.object({
+  replaceWorkspaces: z.array(z.object({
+    pageId: projectIdSchema,
+    scopeId: z.string().trim().min(1).max(240),
+    workspaceKey: z.string().trim().min(1).max(240)
+  })).max(120).optional(),
   scanVersionId: projectIdSchema.nullable().optional(),
   workspaceKey: z.string().trim().min(1, "Нужен workspaceKey semantic block.").max(240),
   scopeId: z.string().trim().min(1, "Нужен scopeId semantic block.").max(240),
diff --git a/seo_mode/seo_mode/server/src/rewrite/rewriteDiff.ts b/seo_mode/seo_mode/server/src/rewrite/rewriteDiff.ts
index bd74639..02495b3 100644
--- a/seo_mode/seo_mode/server/src/rewrite/rewriteDiff.ts
+++ b/seo_mode/seo_mode/server/src/rewrite/rewriteDiff.ts
@@ -349,6 +349,25 @@ function getSemanticBlockSourceBindings(block: SemanticBlockModel) {
   return block.sourceBindings.map(asRecord).filter((binding): binding is Record<string, unknown> => Boolean(binding));
 }
 
+function getSemanticBlockReferencedPageIds(block: SemanticBlockModel) {
+  const pageIds = new Set<string>([block.pageId]);
+  const identityPageIds = Array.isArray(block.identity.memberPageIds) ? block.identity.memberPageIds : [];
+
+  for (const value of identityPageIds) {
+    if (typeof value === "string" && value) pageIds.add(value);
+  }
+
+  for (const anchor of block.anchors.map(asRecord).filter((value): value is Record<string, unknown> => Boolean(value))) {
+    if (typeof anchor.pageId === "string" && anchor.pageId) pageIds.add(anchor.pageId);
+  }
+
+  for (const binding of getSemanticBlockSourceBindings(block)) {
+    if (typeof binding.sourcePageId === "string" && binding.sourcePageId) pageIds.add(binding.sourcePageId);
+  }
+
+  return Array.from(pageIds);
+}
+
 function mapRewriteDiffSemanticBlock(block: SemanticBlockModel): RewriteDiffSemanticBlock {
   return {
     anchors: block.anchors,
@@ -722,7 +741,9 @@ export async function getRewriteDiffContract(projectId: string): Promise<Rewrite
   ]);
   const snapshotMap = await getWorkspaceSnapshotMap(draftMap);
   const semanticBlocksByPageId = semanticBlocks.reduce<Map<string, SemanticBlockModel[]>>((accumulator, block) => {
-    accumulator.set(block.pageId, [...(accumulator.get(block.pageId) ?? []), block]);
+    getSemanticBlockReferencedPageIds(block).forEach((pageId) => {
+      accumulator.set(pageId, [...(accumulator.get(pageId) ?? []), block]);
+    });
     return accumulator;
   }, new Map());
   const targets = rewritePlan.existingPageTargets
diff --git a/seo_mode/seo_mode/server/src/scripts/checkSemanticBlockUniversality.ts b/seo_mode/seo_mode/server/src/scripts/checkSemanticBlockUniversality.ts
index b05f34d..586a791 100644
--- a/seo_mode/seo_mode/server/src/scripts/checkSemanticBlockUniversality.ts
+++ b/seo_mode/seo_mode/server/src/scripts/checkSemanticBlockUniversality.ts
@@ -4,8 +4,14 @@ import {
   collapseCarouselManualSemanticBlockBoxes,
   getCarouselManualBoxBase,
   isCarouselLikeSemanticValue,
+  normalizeSemanticBlockIdFragment,
   type SemanticBlockBoxLike
 } from "../preview/semanticBlockRules.js";
+import {
+  annotatePreviewTargets,
+  getPreviewAtomicTextUnits,
+  getPreviewTargetSeeds
+} from "../workspace/previewTargets.js";
 
 function box(input: Partial<SemanticBlockBoxLike> & Pick<SemanticBlockBoxLike, "id" | "title">): SemanticBlockBoxLike {
   return {
@@ -33,6 +39,79 @@ assert.equal(
   "Plain card lists must not become one carousel entity only because they are indexed."
 );
 
+assert.equal(
+  normalizeSemanticBlockIdFragment("قسم / 产品 / блок"),
+  "قسم-产品-блок",
+  "Semantic ids must retain Unicode letters instead of collapsing non-Latin projects."
+);
+
+const genericCmsFixture = `<!doctype html>
+<html><body>
+  <header><p>Shared product chrome</p></header>
+  <main>
+    <h1>Independent product guide</h1>
+    <p>First editable paragraph from an ordinary CMS theme.</p>
+    <h2>Configuration</h2>
+    <p>Second editable paragraph with <strong>nested inline markup</strong>.</p>
+  </main>
+  <aside><p>Related navigation chrome</p></aside>
+</body></html>`;
+const genericCmsSeeds = getPreviewTargetSeeds(genericCmsFixture);
+const genericTextSeeds = genericCmsSeeds.filter((seed) => seed.kind === "text_unit");
+const genericHeadingSeeds = genericCmsSeeds.filter((seed) => seed.kind === "heading_group");
+const annotatedGenericCms = annotatePreviewTargets(genericCmsFixture, genericCmsSeeds);
+
+assert.equal(genericHeadingSeeds.length, 2, "Generic heading units must be discovered without project vocabulary.");
+assert.equal(genericTextSeeds.length, 4, "CMS paragraphs in content and chrome must receive stable occurrence locators.");
+assert.ok(
+  genericHeadingSeeds.every((seed) => annotatedGenericCms.includes(`data-seo-target-id="${seed.id}"`)) &&
+    genericTextSeeds.every((seed) => annotatedGenericCms.includes(`data-seo-target-id="${seed.id}"`)),
+  "Preview annotation must materialize every generic heading/text-unit locator."
+);
+
+const nestedListFixture = `<body>
+  <ul>
+    <li>Outer item text<ul><li>Inner item text</li></ul></li>
+    <li>Sibling item text</li>
+  </ul>
+</body>`;
+const nestedListSeeds = getPreviewTargetSeeds(nestedListFixture).filter((seed) => seed.kind === "text_unit");
+const annotatedNestedList = annotatePreviewTargets(nestedListFixture, nestedListSeeds);
+
+assert.deepEqual(
+  getPreviewAtomicTextUnits(nestedListFixture).map((unit) => unit.targetIndex),
+  [1, 2, 3],
+  "Nested list items must retain distinct opening-occurrence identities."
+);
+assert.ok(
+  nestedListSeeds.every((seed) => annotatedNestedList.includes(`data-seo-target-id="${seed.id}"`)),
+  "Nested outer, inner, and sibling text units must all be annotated."
+);
+
+const rawScriptFixture = `<body>
+  <script>const template = \`<p>Template-only paragraph</p>\`;</script>
+  <p>Actual editable paragraph</p>
+</body>`;
+const rawScriptSeeds = getPreviewTargetSeeds(rawScriptFixture).filter((seed) => seed.kind === "text_unit");
+const annotatedRawScript = annotatePreviewTargets(rawScriptFixture, rawScriptSeeds);
+
+assert.equal(rawScriptSeeds.length, 1, "Markup-looking script text must not consume atomic target indices.");
+assert.ok(
+  annotatedRawScript.includes("`<p>Template-only paragraph</p>`") &&
+    annotatedRawScript.includes('<p data-seo-target-id="text-unit-1">Actual editable paragraph</p>'),
+  "Preview annotation must preserve raw script bytes and annotate only rendered body text."
+);
+
+const reservedAttributeFixture = `<body><p data-seo-target-id="customer-value">Actual editable paragraph</p></body>`;
+const reservedAttributeSeeds = getPreviewTargetSeeds(reservedAttributeFixture);
+const annotatedReservedAttribute = annotatePreviewTargets(reservedAttributeFixture, reservedAttributeSeeds);
+
+assert.ok(
+  annotatedReservedAttribute.includes('data-seo-target-id="text-unit-1"') &&
+    !annotatedReservedAttribute.includes('data-seo-target-id="customer-value"'),
+  "A pre-existing reserved annotation must be rebound to the selector emitted by the workspace seed."
+);
+
 assert.deepEqual(getCarouselManualBoxBase(box({ id: "semantic-block:gallery:visual-2", title: "Gallery 2" })), {
   id: "semantic-block:gallery",
   title: "Gallery"
@@ -80,9 +159,12 @@ const collapsedTitleOnlyBoxes = collapseCarouselManualSemanticBlockBoxes([
   box({ geometry: { height: 240, left: 600, top: 0, width: 320 }, id: "manual-3", title: "Слайдер 3", left: 600, targetIds: ["slide-3"] })
 ]);
 
-assert.equal(collapsedTitleOnlyBoxes.length, 1, "Legacy title-only slider boxes must collapse after reload.");
-assert.equal(collapsedTitleOnlyBoxes[0]?.id, "manual-carousel:слайдер");
-assert.equal(collapsedTitleOnlyBoxes[0]?.title, "Слайдер");
+assert.equal(
+  collapsedTitleOnlyBoxes.length,
+  3,
+  "Numbered titles and nearby geometry must not invent semantic membership after reload."
+);
+assert.deepEqual(collapsedTitleOnlyBoxes.map((item) => item.id), ["manual-1", "manual-2", "manual-3"]);
 
 const separateRows = collapseCarouselManualSemanticBlockBoxes([
   box({ geometry: { height: 240, left: 0, top: 0, width: 320 }, id: "row-a", title: "Слайдер 1", top: 0, targetIds: ["a"] }),
@@ -107,10 +189,15 @@ assert.equal(plainBlocks.length, 2, "Plain numbered semantic blocks must stay se
 
 const previewBridgeSource = await readFile(new URL("../preview/routes.ts", import.meta.url), "utf8");
 const semanticBlockRepositorySource = await readFile(new URL("../workspace/semanticBlocks.ts", import.meta.url), "utf8");
+const pageWorkspaceSource = await readFile(new URL("../workspace/pageWorkspace.ts", import.meta.url), "utf8");
 const semanticBlockMigrationSource = await readFile(new URL("../../migrations/010_semantic_blocks.sql", import.meta.url), "utf8");
 const rewriteDiffSource = await readFile(new URL("../rewrite/rewriteDiff.ts", import.meta.url), "utf8");
 const visualComposerSource = await readFile(new URL("../rewrite/visualComposerVariants.ts", import.meta.url), "utf8");
 const appSource = await readFile(new URL("../../../app/src/App.tsx", import.meta.url), "utf8");
+const previewBridgeBodySource = previewBridgeSource.slice(
+  previewBridgeSource.indexOf("function buildPreviewBridgeScript()"),
+  previewBridgeSource.indexOf("function buildPreviewFocusScript(")
+);
 
 assert.ok(
   !/const\s+SEMANTIC_BLOCK_EDITOR_ENABLED\s*=\s*false/.test(appSource),
@@ -128,6 +215,171 @@ assert.ok(
   previewBridgeSource.includes("function isSafePreviewPatchElement"),
   "Preview bridge must keep a safe-patch gate before mutating iframe DOM."
 );
+assert.ok(
+  previewBridgeSource.includes("function getSemanticBlockMemberEntries") &&
+    previewBridgeSource.includes("function createAdaptiveSemanticBlockVisuals"),
+  "Stage 07 must render one semantic group as adaptive member outlines instead of one persisted viewport rectangle."
+);
+assert.ok(
+  previewBridgeSource.includes("row and geometry are diagnostics and never define membership"),
+  "Responsive geometry must remain a diagnostic cache, never a semantic merge key."
+);
+assert.ok(
+  previewBridgeSource.includes("toggleTextUnitInSelectedSemanticBlock") &&
+    previewBridgeSource.includes("removeTextUnitFromSemanticBlock") &&
+    previewBridgeSource.includes("Commit explicit membership only"),
+  "Semantic membership must change only through explicit text-unit interaction, never rectangle intersection."
+);
+assert.ok(
+  previewBridgeSource.includes("Automatic layout suggestions stay suggestions") &&
+    !/function renderSemanticBlockBoxes[\s\S]{0,500}seedSemanticBlockEditBoxes\(/.test(previewBridgeSource),
+  "Opening the editor must not promote automatic suggestions into manual groups."
+);
+assert.ok(
+  previewBridgeSource.includes("One ID · several adaptive outlines") ||
+    (previewBridgeSource.includes("seo-mode-semantic-member") && appSource.includes("Один ID · несколько адаптивных контуров")),
+  "Disjoint semantic members must stay one group without a giant union frame."
+);
+assert.ok(
+  !previewBridgeSource.includes("state.semanticBlockEditMode && state.hasManualSemanticBlockSet) {\n            return;"),
+  "Semantic block editing must continue measuring during viewport and layout changes."
+);
+assert.ok(
+  previewBridgeSource.includes("ResizeObserver(scheduleDynamicLayoutMeasure)") &&
+    previewBridgeSource.includes('document.fonts.addEventListener?.("loadingdone"') &&
+    previewBridgeSource.includes('window.visualViewport?.addEventListener("resize"'),
+  "Preview projection must observe responsive layout, late fonts, and visual viewport changes."
+);
+assert.ok(
+  previewBridgeSource.includes('type: "seo-mode:text-unit-select"') &&
+    previewBridgeSource.includes("function getInspectableTextElementAtPoint") &&
+    previewBridgeSource.includes("function getTextNodeAtPoint") &&
+    previewBridgeSource.includes("function handleTextInspectorPointerDown") &&
+    previewBridgeSource.includes("function getPresentedTextVisualElement") &&
+    !previewBridgeSource.includes('document.addEventListener("click", handleTextInspectorClick') &&
+    appSource.includes("Текстовый фрагмент") &&
+    appSource.includes("workspaceTextInspectorSelections"),
+  "Stage 07 must select split-animation and ordinary text exactly once without changing page layout."
+);
+assert.equal(
+  previewBridgeBodySource.match(/(^|[^\\])\\[bBdDsSwW]/g),
+  null,
+  "Regex character-class escapes inside the injected preview script must be doubled; otherwise they become literal letters."
+);
+assert.ok(
+  appSource.includes("markerVisible: activeStageIndex !== 6") &&
+    appSource.includes("!isVisualComposerMode ? <div className=\"workspace-preview-markers\">"),
+  "Legacy numbered rewrite markers must stay out of the stage 07 visual editor."
+);
+assert.ok(
+  appSource.includes("const planReady = strategyReady || Boolean(input.rewritePlan)") &&
+    appSource.includes("unlocked: planReady") &&
+    appSource.includes("fetchLatestRewritePlan(projectId)") &&
+    appSource.includes("загружаю доступ к этапам..."),
+  "Persisted rewrite plans must unlock only stage 07 during deterministic project hydration without waiting for strategy recomputation."
+);
+assert.ok(
+  previewBridgeSource.includes("function isTargetTextConsistent") &&
+    previewBridgeSource.includes("if (targetElement === element) return { target, score: 0 }") &&
+    previewBridgeSource.includes("if (element.contains(targetElement)) return { target, score: 1 }") &&
+    previewBridgeSource.includes("selectorIndex: getElementSelectorIndex(element, selector)"),
+  "Text inspector source writes must preserve text-consistent logical-unit binding and duplicate-selector identity."
+);
+assert.ok(
+  appSource.includes("workspaceTextInspectorModes[projectId]") &&
+    appSource.includes("workspaceTextInspectorSelections[project.id]"),
+  "Inspector mode and selection must remain page-session stable while the active semantic scope changes."
+);
+assert.ok(
+  appSource.includes("function getSemanticBlockOwnerWorkspaceKey") &&
+    appSource.includes("getWorkspaceRenderedPageKey(item, scopeItems, scanSummary) === renderedPageKey") &&
+    appSource.includes("mergeSemanticBlockOverrideMembership") &&
+    appSource.includes("selectedSemanticBlockIds[activeSemanticBlockEditorSessionKey]"),
+  "One rendered page must have one canonical group projection across source workspaces and scope changes."
+);
+assert.ok(
+  appSource.includes('return `page:${scopeItem.pageId}`') &&
+    appSource.includes("function getWorkspaceSectionHostPage") &&
+    appSource.includes("logicalHostPages.length === 1") &&
+    appSource.includes("section.selected || Boolean(getWorkspaceSectionHostPage(scan, section))") &&
+    appSource.includes("getWorkspaceSectionHostPage(scan, scopeItem)") &&
+    appSource.includes('return `scope:${scopeItem.scopeId}`') &&
+    !/function normalizeWorkspacePreviewSourceKey[\s\S]{0,220}toLocaleLowerCase/.test(appSource),
+  "Rendered-page identity must isolate shared-index SPA routes, reuse one unambiguous section host, and preserve case-sensitive source paths."
+);
+assert.ok(
+  appSource.includes("function getSemanticBlockResolvedTargets") &&
+    appSource.includes("identityAnchors.length === 0 && candidates.length === 1") &&
+    appSource.includes("targetsBySourceIdentity") &&
+    appSource.includes('const sourceIdentity = `${sourceWorkspaceKey}\\u0000${target.id}`'),
+  "Repeated atomic target ids must retain workspace ownership and bind only through explicit scope/page identity or a unique legacy fallback."
+);
+assert.ok(
+  appSource.includes("projectWorkspaceGenerationsRef") &&
+    appSource.includes("function invalidateProjectWorkspaceCaches") &&
+    appSource.includes("invalidateProjectWorkspaceCaches(project.id)") &&
+    appSource.includes("getProjectWorkspaceGeneration(project.id) !== workspaceGeneration") &&
+    appSource.includes("prefetchingWorkspaceKeysRef.current.delete(prefetchKey)") &&
+    appSource.includes("if (cachedWorkspace)") &&
+    appSource.includes("Reopening an already hydrated scope is navigation, not a reload"),
+  "A successful rescan must invalidate Stage 3/7 caches, reject stale in-flight results, and preserve local text on cache-first navigation."
+);
+assert.ok(
+  !previewBridgeSource.includes(".c-viz") &&
+    !previewBridgeSource.includes("getScopedAnchorFallbackElement") &&
+    !appSource.includes("getWorkspaceScopedAnchorFallbackSelector"),
+  "Preview scope resolution must not depend on NODE.DC classes or synthesized section-anchor ids."
+);
+assert.ok(
+  pageWorkspaceSource.includes('seed.kind === "text_unit"') &&
+    pageWorkspaceSource.includes('"atomic_dom_text_units"') &&
+    pageWorkspaceSource.includes("function getPrimaryContentRange") &&
+    pageWorkspaceSource.includes("getPreviewAtomicTextUnits(html)") &&
+    pageWorkspaceSource.includes("Atomic units are identities, not text values") &&
+    !appSource.includes("rewriteTargets.length === 0 && contentFieldTargets.length === 0"),
+  "Oversized primary content must split into generic atomic text units without hiding remaining text when one plan slot exists."
+);
+assert.ok(
+  pageWorkspaceSource.includes("item.working_text == null || item.working_text === snapshot.originalText") &&
+    pageWorkspaceSource.includes("!draftIsUnchanged && (!belongsToCurrentScan || !isCurrentSnapshot)") &&
+    pageWorkspaceSource.includes("anchor-aware conflict/rebase flow"),
+  "Changed and intentionally empty drafts must never be positionally rebased onto an atomic snapshot topology."
+);
+assert.ok(
+  previewBridgeSource.includes("sources.length === 1") &&
+    previewBridgeSource.includes("presentations.length === 1") &&
+    previewBridgeSource.includes("!semanticSourceElement && isSafePreviewPatchElement(patchElement)") &&
+    previewBridgeSource.includes("function hasPresentedTextCompanion") &&
+    previewBridgeSource.includes("Number(anchor.selectorIndex || 0) === selectorIndex"),
+  "Split-text adapters must reject ambiguous responsive/accessibility clones and retain selector occurrence identity."
+);
+assert.ok(
+  previewBridgeSource.includes("readElementText(element) === record.lastAppliedText") &&
+    previewBridgeSource.includes("if (applied) restoreAppliedSection(sectionId, applied)") &&
+    previewBridgeSource.includes("owners?.size !== 1") &&
+    previewBridgeSource.includes("target.preferPageStart") &&
+    !/function getTargetElement\(target, options\) \{[\s\S]{0,260}appliedSectionTexts\.get/.test(previewBridgeSource),
+  "Preview draft patches must restore replaced elements, reject competing bindings, and never overwrite runtime-owned text."
+);
+assert.ok(
+  semanticBlockRepositorySource.includes("replaceWorkspaces") &&
+    semanticBlockRepositorySource.includes("for (const entry of replaceWorkspaces)") &&
+    appSource.includes("replaceWorkspaces: canonicalWorkspaceKeys.flatMap"),
+  "Canonical page saves must archive legacy workspace copies in the same backend transaction."
+);
+assert.ok(
+  previewBridgeSource.includes("bridgeSessionToken") &&
+    previewBridgeSource.includes("isTrustedParentMessage") &&
+    previewBridgeSource.includes("bridgeScriptElement?.remove()") &&
+    previewBridgeSource.includes("${headTag}${baseTag}${stabilityStyle}${bridgeScript}") &&
+    appSource.includes("previewBridgeTokensRef"),
+  "Imported page scripts must not be able to forge authenticated Stage 07 commits."
+);
+assert.ok(
+  previewBridgeSource.includes("const capturedEntities = textUnit.targetId") &&
+    previewBridgeSource.includes("state.semanticBlockEditMode || state.textInspectorMode ? 72 : 180"),
+  "One bound text unit must render once, and adaptive outlines must follow nested scrolling."
+);
 assert.ok(
   /const\s+blockedTags\s*=\s*new\s+Set\([\s\S]*"section"[\s\S]*"article"[\s\S]*"form"/.test(previewBridgeSource),
   "Preview bridge must block text writes into layout containers."
@@ -147,21 +399,21 @@ assert.ok(
 assert.ok(
   semanticBlockRepositorySource.includes("hasSemanticBlockRuntimeBinding") &&
     semanticBlockRepositorySource.includes("sourceBindings.length > 0"),
-  "Semantic block repository must not persist captured-only visual boxes without text target/source bindings."
+  "Semantic block repository must retain context-only DOM members through typed source bindings."
 );
 assert.ok(
   appSource.includes("hydratePersistedWorkspaceSemanticBlocks") && appSource.includes("savePageSemanticBlocks"),
   "Stage 07 semantic block overrides must reload from and save to backend."
 );
 assert.ok(
-  appSource.includes("skippedSemanticBlockCount") &&
-    appSource.includes("sourceBindings.length === 0") &&
-    appSource.includes("без текстовой привязки"),
-  "Stage 07 must skip semantic block saves that have no runtime text source binding."
+  appSource.includes('source: "captured_dom" as const') &&
+    appSource.includes("contextOnly: true") &&
+    appSource.includes('ontologyEntityId: "seo.semantic_block"'),
+  "Unbound text must remain groupable and persist as context-only membership with ontology identity."
 );
 assert.ok(
-  appSource.includes("anchorTargetIds") && /return blockKey && targetIds\.length > 0/.test(appSource),
-  "Persisted semantic block hydration must require target-bound anchors or targetIds."
+  appSource.includes("capturedEntities.length > 0 || anchors.length > 0 || block.sourceBindings.length > 0"),
+  "Persisted semantic block hydration must retain captured/context-only members without a writable target."
 );
 assert.ok(
   rewriteDiffSource.includes("listSemanticBlocksForPages") &&
@@ -170,7 +422,8 @@ assert.ok(
     rewriteDiffSource.includes("buildSemanticRewriteGroups") &&
     rewriteDiffSource.includes("fallbackReason: slot.semanticBlock ? null : \"no_semantic_block\"") &&
     rewriteDiffSource.includes("buildSemanticGroupSourceGraph") &&
-    rewriteDiffSource.includes("contentFieldCount"),
+    rewriteDiffSource.includes("contentFieldCount") &&
+    rewriteDiffSource.includes("getSemanticBlockReferencedPageIds"),
   "Rewrite diff must attach persisted semantic blocks and build semantic rewrite groups with source graph."
 );
 assert.ok(
diff --git a/seo_mode/seo_mode/server/src/workspace/pageWorkspace.ts b/seo_mode/seo_mode/server/src/workspace/pageWorkspace.ts
index ba9a01d..527e19c 100644
--- a/seo_mode/seo_mode/server/src/workspace/pageWorkspace.ts
+++ b/seo_mode/seo_mode/server/src/workspace/pageWorkspace.ts
@@ -2,7 +2,13 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { pool } from "../db/client.js";
 import { storageProvider } from "../storage/index.js";
-import { annotatePreviewTargets, getPreviewTargetSelector, getPreviewTargetSeeds } from "./previewTargets.js";
+import {
+  annotatePreviewTargets,
+  getPreviewAtomicTextUnits,
+  getPreviewHeadingUnits,
+  getPreviewTargetSelector,
+  getPreviewTargetSeeds
+} from "./previewTargets.js";
 
 type PageWorkspaceSourceRow = {
   project_id: string;
@@ -131,9 +137,9 @@ export class PageWorkspaceError extends Error {
 
 const WORKSPACE_FIELD = "page_text";
 const MAX_BLOCK_TEXT_LENGTH = 6_000;
-const MAX_SECTIONS = 80;
+const MAX_SECTIONS = 240;
 const MAX_MEDIA_SECTIONS = 80;
-const WORKSPACE_GROUPING_VERSION_EVIDENCE = "workspace_grouping_v3";
+const WORKSPACE_GROUPING_VERSION_EVIDENCE = "workspace_grouping_v7_safe_atomic_text";
 const MAX_SOURCE_ORDER_CLUSTER_SIZE = 12;
 const MAX_CLUSTER_SECTION_CHARS = 900;
 
@@ -404,6 +410,108 @@ function extractHeadingSections(html: string) {
   return dedupeSections(sections);
 }
 
+function getPrimaryContentRange(bodyHtml: string) {
+  for (const tagName of ["main", "article"]) {
+    const match = new RegExp(`<${tagName}\\b[^>]*>([\\s\\S]*?)<\\/${tagName}>`, "i").exec(bodyHtml);
+
+    if (!match || match.index == null) {
+      continue;
+    }
+
+    const openingTagEnd = match[0].indexOf(">") + 1;
+    const closingTagStart = match[0].toLocaleLowerCase().lastIndexOf(`</${tagName}>`);
+
+    return {
+      end: match.index + (closingTagStart >= 0 ? closingTagStart : match[0].length),
+      start: match.index + Math.max(0, openingTagEnd)
+    };
+  }
+
+  return { end: bodyHtml.length, start: 0 };
+}
+
+function getAtomicTextUnitTitle(tagName: string, text: string, index: number) {
+  const normalizedText = normalizeWhitespace(text);
+
+  if (/^h[1-6]$/.test(tagName)) {
+    return `${tagName.toUpperCase()}: ${normalizedText}`;
+  }
+
+  const summary = normalizedText.length > 92 ? `${normalizedText.slice(0, 89)}...` : normalizedText;
+  return summary || `${tagName.toUpperCase()} ${index}`;
+}
+
+function extractAtomicTextSections(html: string) {
+  const bodyHtml = getBodyHtml(html);
+  const primaryRange = getPrimaryContentRange(bodyHtml);
+  const seeds = getPreviewTargetSeeds(html);
+  const headingSeeds = seeds.filter((seed) => seed.kind === "heading_group");
+  const textUnitSeeds = seeds.filter((seed) => seed.kind === "text_unit");
+  const entries: Array<{ section: PageWorkspaceSection; sourceIndex: number }> = [];
+
+  for (const headingUnit of getPreviewHeadingUnits(html)) {
+    const sourceIndex = headingUnit.sourceIndex;
+
+    if (sourceIndex < primaryRange.start || sourceIndex >= primaryRange.end) {
+      continue;
+    }
+
+    const text = htmlToReadableText(headingUnit.contentHtml);
+    const seed = headingSeeds.find((candidate) => candidate.targetIndex === headingUnit.targetIndex);
+
+    if (!seed || text.length < 2) {
+      continue;
+    }
+
+    entries.push({
+      section: makeSection({
+        id: seed.id,
+        kind: "heading_group",
+        title: getAtomicTextUnitTitle(headingUnit.tagName, text, headingUnit.targetIndex),
+        selector: seed.selector,
+        originalText: text,
+        sourceHint: seed.sourceHint
+      }),
+      sourceIndex
+    });
+  }
+
+  for (const textUnit of getPreviewAtomicTextUnits(html)) {
+    const sourceIndex = textUnit.sourceIndex;
+
+    if (sourceIndex < primaryRange.start || sourceIndex >= primaryRange.end) {
+      continue;
+    }
+
+    const text = htmlToReadableText(textUnit.contentHtml);
+    const seed = textUnitSeeds.find((candidate) => candidate.targetIndex === textUnit.targetIndex);
+
+    if (!seed || text.length < 8) {
+      continue;
+    }
+
+    entries.push({
+      section: makeSection({
+        id: seed.id,
+        kind: "content_block",
+        title: getAtomicTextUnitTitle(textUnit.tagName, text, textUnit.targetIndex),
+        selector: seed.selector,
+        originalText: text,
+        sourceHint: seed.sourceHint
+      }),
+      sourceIndex
+    });
+  }
+
+  // Atomic units are identities, not text values. Repeated CTA/list copy is
+  // still a distinct DOM/source unit and must not disappear through text
+  // deduplication. Apply the page cap only after restoring DOM source order.
+  return entries
+    .sort((left, right) => left.sourceIndex - right.sourceIndex)
+    .slice(0, MAX_SECTIONS)
+    .map((entry) => entry.section);
+}
+
 function extractMediaSections(html: string) {
   const bodyHtml = getBodyHtml(html);
   const mediaPattern = /<(img|video)\b([^>]*)>/gi;
@@ -475,7 +583,13 @@ function isSourceOrderClusterCandidate(section: PageWorkspaceSection) {
     return false;
   }
 
-  if (section.sourceHint === "<main>" || section.sourceHint === "<header>" || section.sourceHint === "<footer>" || section.sourceHint === "<nav>") {
+  if (
+    section.sourceHint === "<main>" ||
+    section.sourceHint === "<header>" ||
+    section.sourceHint === "<footer>" ||
+    section.sourceHint === "<nav>" ||
+    section.sourceHint === "<aside>"
+  ) {
     return false;
   }
 
@@ -518,6 +632,62 @@ function getDefaultSemanticGroup(section: PageWorkspaceSection): PageWorkspaceSe
   };
 }
 
+function attachAtomicHeadingRangeGroups(sections: PageWorkspaceSection[]) {
+  const groups: PageWorkspaceSection[][] = [];
+  let currentGroup: PageWorkspaceSection[] = [];
+
+  for (const section of sections) {
+    if (section.kind === "heading_group" && currentGroup.length > 0) {
+      groups.push(currentGroup);
+      currentGroup = [];
+    }
+
+    currentGroup.push(section);
+  }
+
+  if (currentGroup.length > 0) {
+    groups.push(currentGroup);
+  }
+
+  const semanticGroups = new Map<string, PageWorkspaceSemanticGroup>();
+
+  groups.forEach((group) => {
+    const heading = group[0]?.kind === "heading_group" ? group[0] : null;
+
+    if (!heading) {
+      group.forEach((section) => semanticGroups.set(section.id, getDefaultSemanticGroup(section)));
+      return;
+    }
+
+    group.forEach((section, fieldOrder) => {
+      semanticGroups.set(section.id, {
+        confidence: 0.82,
+        evidence: [
+          WORKSPACE_GROUPING_VERSION_EVIDENCE,
+          "heading_range",
+          "atomic_dom_text_units",
+          "source_order"
+        ],
+        fieldCount: group.length,
+        fieldOrder,
+        fieldRole: getWorkspaceSectionRole({
+          id: section.id,
+          kind: section.kind,
+          title: section.title
+        }),
+        id: `semantic-block:heading-range:${heading.id}`,
+        source: "workspace_section",
+        title: heading.title
+      });
+    });
+  });
+
+  return sections.map((section) => ({
+    ...section,
+    semanticGroup: semanticGroups.get(section.id) ?? getDefaultSemanticGroup(section)
+  }));
+}
+
 function getSourceOrderClusterGroup(
   run: PageWorkspaceSection[],
   section: PageWorkspaceSection,
@@ -600,6 +770,21 @@ function attachSemanticGroups(sections: PageWorkspaceSection[]) {
   }));
 }
 
+function getPageContentSections(html: string) {
+  const semanticSections = extractSemanticSections(html);
+  const hasSafeContentSection = semanticSections.some(isSourceOrderClusterCandidate);
+
+  if (!hasSafeContentSection) {
+    const atomicTextSections = extractAtomicTextSections(html);
+
+    if (atomicTextSections.length > 0) {
+      return attachAtomicHeadingRangeGroups(atomicTextSections);
+    }
+  }
+
+  return semanticSections.length >= 2 ? semanticSections : extractHeadingSections(html);
+}
+
 function buildPreviewHtml(html: string) {
   const previewStyles = `
     <style>
@@ -660,16 +845,14 @@ function buildSections(page: PageWorkspaceSourceRow, html: string): PageWorkspac
     }));
   }
 
-  const semanticSections = extractSemanticSections(html);
-  const contentSections = semanticSections.length >= 2 ? semanticSections : extractHeadingSections(html);
+  const contentSections = getPageContentSections(html);
   const mediaSections = extractMediaSections(html);
 
   return attachSemanticGroups([...sections, ...contentSections, ...mediaSections]);
 }
 
 function buildIssueAlignedSections(page: PageWorkspaceSourceRow, html: string): PageWorkspaceSection[] {
-  const semanticSections = extractSemanticSections(html);
-  const contentSections = semanticSections.length >= 2 ? semanticSections : extractHeadingSections(html);
+  const contentSections = getPageContentSections(html);
   const mediaSections = extractMediaSections(html);
   const pageAnchorSelector = contentSections[0]?.selector ?? mediaSections[0]?.selector ?? getPreviewTargetSelector("block-1");
   const h1Section = contentSections.find((section) => section.title.toLocaleLowerCase().startsWith("h1:"));
@@ -895,6 +1078,11 @@ function buildSnapshot(page: PageWorkspaceSourceRow, html: string): WorkspaceSna
 
 async function getUpgradedSnapshot(page: PageWorkspaceSourceRow, item: DraftItemRow) {
   const snapshot = await readOriginalSnapshot(item.original_snapshot_key);
+  const draftIsUnchanged = item.working_text == null || item.working_text === snapshot.originalText;
+  const belongsToCurrentScan =
+    snapshot.scanVersionId === page.scan_version_id &&
+    snapshot.pageId === page.page_id &&
+    snapshot.sourcePath === page.source_path;
   const mediaCount = Math.min(countMediaTags(snapshot.originalHtml ?? ""), MAX_MEDIA_SECTIONS);
   const mediaSectionCount = snapshot.sections.filter((section) => section.kind === "media").length;
   const isCurrentSnapshot =
@@ -906,16 +1094,26 @@ async function getUpgradedSnapshot(page: PageWorkspaceSourceRow, item: DraftItem
     snapshot.sections.some((section) => section.kind === "content_block" || section.kind === "heading_group") &&
     snapshot.sections.every((section) => Boolean(section.anchor?.entityType) && "fingerprint" in section.anchor) &&
     snapshot.sections.every((section) =>
-      Boolean(section.semanticGroup?.evidence.includes(WORKSPACE_GROUPING_VERSION_EVIDENCE))
+      Boolean(section.semanticGroup?.evidence?.includes(WORKSPACE_GROUPING_VERSION_EVIDENCE))
     ) &&
     (!/<(img|video)\b/i.test(snapshot.originalHtml ?? "") || mediaSectionCount >= mediaCount) &&
     snapshot.sections.every((section) => section.kind === "meta" || section.selector?.includes("data-seo-target-id"));
 
-  if (isCurrentSnapshot) {
+  if (isCurrentSnapshot && belongsToCurrentScan) {
     return snapshot;
   }
 
-  const html = snapshot.originalHtml || (await readPageHtml(page));
+  // Never positionally map a changed draft onto a different scan or section
+  // topology. Atomic upgrades can turn one legacy container into hundreds of
+  // fields, so changed workspaces keep their immutable source snapshot until
+  // a dedicated anchor-aware conflict/rebase flow is accepted.
+  if (!draftIsUnchanged && (!belongsToCurrentScan || !isCurrentSnapshot)) {
+    return snapshot;
+  }
+
+  const html = belongsToCurrentScan
+    ? snapshot.originalHtml || (await readPageHtml(page))
+    : await readPageHtml(page);
   const upgradedSnapshot = buildSnapshot(page, html);
 
   if (item.original_snapshot_key) {
@@ -926,7 +1124,7 @@ async function getUpgradedSnapshot(page: PageWorkspaceSourceRow, item: DraftItem
     });
   }
 
-  if (!item.working_text || item.working_text === snapshot.originalText) {
+  if (draftIsUnchanged) {
     await pool.query(
       `
         update draft_items
diff --git a/seo_mode/seo_mode/server/src/workspace/previewTargets.ts b/seo_mode/seo_mode/server/src/workspace/previewTargets.ts
index 7eefc0b..1f7a78d 100644
--- a/seo_mode/seo_mode/server/src/workspace/previewTargets.ts
+++ b/seo_mode/seo_mode/server/src/workspace/previewTargets.ts
@@ -1,11 +1,37 @@
 export type PreviewTargetSeed = {
   id: string;
-  kind: "content_block" | "heading_group" | "media";
+  kind: "content_block" | "heading_group" | "media" | "text_unit";
   selector: string;
   sourceHint: string;
   targetIndex: number;
 };
 
+export type PreviewAtomicTextUnit = {
+  contentHtml: string;
+  documentSourceIndex: number;
+  openingTagEndIndex: number;
+  sourceIndex: number;
+  tagName: string;
+  targetIndex: number;
+};
+
+type HtmlTagToken = {
+  closing: boolean;
+  end: number;
+  selfClosing: boolean;
+  start: number;
+  tagName: string;
+};
+
+type ProtectedHtml = {
+  html: string;
+  restore: (value: string) => string;
+};
+
+const RAW_TEXT_BLOCK_PATTERN = /<(script|style|svg|noscript|template|textarea)\b[^>]*>[\s\S]*?<\/\1>/gi;
+const ATOMIC_TEXT_TAGS = new Set(["p", "li", "blockquote", "figcaption", "dt", "dd"]);
+const HEADING_TAGS = new Set(["h1", "h2", "h3", "h4", "h5", "h6"]);
+
 function normalizeWhitespace(value: string) {
   return value.replace(/\s+/g, " ").trim();
 }
@@ -15,13 +41,192 @@ function getBodyHtml(html: string) {
   return bodyMatch?.[1] ?? html;
 }
 
+function maskRawTextBlocks(html: string) {
+  return html.replace(RAW_TEXT_BLOCK_PATTERN, (block) => " ".repeat(block.length));
+}
+
+function protectRawTextBlocks(html: string): ProtectedHtml {
+  const blocks: string[] = [];
+  const protectedHtml = html.replace(RAW_TEXT_BLOCK_PATTERN, (block) => {
+    const index = blocks.push(block) - 1;
+    return `\uE000SEO_MODE_RAW_${index}\uE001`;
+  });
+
+  return {
+    html: protectedHtml,
+    restore: (value) => value.replace(/\uE000SEO_MODE_RAW_(\d+)\uE001/g, (_token, rawIndex: string) => {
+      return blocks[Number(rawIndex)] ?? "";
+    })
+  };
+}
+
+function scanHtmlTags(html: string) {
+  const tokens: HtmlTagToken[] = [];
+  let cursor = 0;
+
+  while (cursor < html.length) {
+    const start = html.indexOf("<", cursor);
+
+    if (start < 0) {
+      break;
+    }
+
+    if (html.startsWith("<!--", start)) {
+      const commentEnd = html.indexOf("-->", start + 4);
+      cursor = commentEnd >= 0 ? commentEnd + 3 : html.length;
+      continue;
+    }
+
+    let quote = "";
+    let end = start + 1;
+
+    for (; end < html.length; end += 1) {
+      const character = html[end] ?? "";
+
+      if (quote) {
+        if (character === quote) quote = "";
+        continue;
+      }
+
+      if (character === "\"" || character === "'") {
+        quote = character;
+        continue;
+      }
+
+      if (character === ">") {
+        break;
+      }
+    }
+
+    if (end >= html.length) {
+      break;
+    }
+
+    const rawTag = html.slice(start, end + 1);
+    const parsed = /^<\s*(\/?)\s*([A-Za-z][\w:-]*)\b/.exec(rawTag);
+
+    if (parsed) {
+      tokens.push({
+        closing: parsed[1] === "/",
+        end: end + 1,
+        selfClosing: /\/\s*>$/.test(rawTag),
+        start,
+        tagName: (parsed[2] ?? "").toLocaleLowerCase()
+      });
+    }
+
+    cursor = end + 1;
+  }
+
+  return tokens;
+}
+
+function getBodyContentRange(html: string) {
+  const tokens = scanHtmlTags(html);
+  const openingBody = tokens.find((token) => token.tagName === "body" && !token.closing);
+
+  if (!openingBody) {
+    return { end: html.length, start: 0 };
+  }
+
+  const closingBody = tokens.find(
+    (token) => token.tagName === "body" && token.closing && token.start >= openingBody.end
+  );
+
+  return {
+    end: closingBody?.start ?? html.length,
+    start: openingBody.end
+  };
+}
+
+function getMatchedTextUnits(html: string, allowedTags: Set<string>) {
+  const maskedHtml = maskRawTextBlocks(html);
+  const bodyRange = getBodyContentRange(maskedHtml);
+  const maskedBodyHtml = maskedHtml.slice(bodyRange.start, bodyRange.end);
+  const originalBodyHtml = html.slice(bodyRange.start, bodyRange.end);
+  const openElements: Array<{
+    openingEnd: number;
+    openingStart: number;
+    tagName: string;
+    targetIndex: number;
+  }> = [];
+  const matches: PreviewAtomicTextUnit[] = [];
+  let targetIndex = 0;
+
+  for (const token of scanHtmlTags(maskedBodyHtml)) {
+    if (!allowedTags.has(token.tagName)) {
+      continue;
+    }
+
+    if (!token.closing) {
+      targetIndex += 1;
+
+      if (!token.selfClosing) {
+        openElements.push({
+          openingEnd: token.end,
+          openingStart: token.start,
+          tagName: token.tagName,
+          targetIndex
+        });
+      }
+
+      continue;
+    }
+
+    let openingIndex = -1;
+
+    for (let index = openElements.length - 1; index >= 0; index -= 1) {
+      if (openElements[index]?.tagName === token.tagName) {
+        openingIndex = index;
+        break;
+      }
+    }
+
+    if (openingIndex < 0) {
+      continue;
+    }
+
+    const opening = openElements[openingIndex];
+    openElements.splice(openingIndex, 1);
+
+    if (!opening) {
+      continue;
+    }
+
+    matches.push({
+      contentHtml: originalBodyHtml.slice(opening.openingEnd, token.start),
+      documentSourceIndex: bodyRange.start + opening.openingStart,
+      openingTagEndIndex: bodyRange.start + opening.openingEnd,
+      sourceIndex: opening.openingStart,
+      tagName: opening.tagName,
+      targetIndex: opening.targetIndex
+    });
+  }
+
+  return matches.sort((left, right) => left.sourceIndex - right.sourceIndex);
+}
+
+export function getPreviewAtomicTextUnits(html: string) {
+  return getMatchedTextUnits(html, ATOMIC_TEXT_TAGS);
+}
+
+export function getPreviewHeadingUnits(html: string) {
+  return getMatchedTextUnits(html, HEADING_TAGS);
+}
+
 function getAttribute(attributes: string, name: string) {
   const pattern = new RegExp(`${name}\\s*=\\s*["']([^"']*)["']`, "i");
   return pattern.exec(attributes)?.[1] ?? null;
 }
 
 function htmlToPlainText(html: string) {
-  return normalizeWhitespace(html.replace(/<script\b[\s\S]*?<\/script>/gi, " ").replace(/<style\b[\s\S]*?<\/style>/gi, " ").replace(/<[^>]+>/g, " "));
+  return normalizeWhitespace(
+    html
+      .replace(/\uE000SEO_MODE_RAW_\d+\uE001/g, " ")
+      .replace(/<script\b[\s\S]*?<\/script>/gi, " ")
+      .replace(/<style\b[\s\S]*?<\/style>/gi, " ")
+      .replace(/<[^>]+>/g, " ")
+  );
 }
 
 function escapeAttribute(value: string) {
@@ -29,8 +234,10 @@ function escapeAttribute(value: string) {
 }
 
 function injectAttribute(openingTag: string, name: string, value: string) {
-  if (new RegExp(`\\s${name}\\s*=`, "i").test(openingTag)) {
-    return openingTag;
+  const existingAttributePattern = new RegExp(`(\\s${name}\\s*=\\s*)(?:["'][^"']*["']|[^\\s>]+)`, "i");
+
+  if (existingAttributePattern.test(openingTag)) {
+    return openingTag.replace(existingAttributePattern, `$1"${escapeAttribute(value)}"`);
   }
 
   return openingTag.replace(/\/?\s*>$/, (ending) => ` ${name}="${escapeAttribute(value)}"${ending}`);
@@ -41,13 +248,14 @@ export function getPreviewTargetSelector(targetId: string) {
 }
 
 export function getPreviewTargetSeeds(html: string) {
-  const bodyHtml = getBodyHtml(html);
+  const bodyHtml = getBodyHtml(maskRawTextBlocks(html));
   const seeds: PreviewTargetSeed[] = [];
   const blockPattern = /<(section|article|header|main|footer|aside|nav)\b([^>]*)>([\s\S]*?)<\/\1>/gi;
   let blockMatch: RegExpExecArray | null;
   let blockIndex = 1;
+  let blockSeedCount = 0;
 
-  while ((blockMatch = blockPattern.exec(bodyHtml)) && seeds.length < 80) {
+  while ((blockMatch = blockPattern.exec(bodyHtml))) {
     const tagName = blockMatch[1] ?? "section";
     const blockHtml = blockMatch[3] ?? "";
     const text = htmlToPlainText(blockHtml);
@@ -56,6 +264,10 @@ export function getPreviewTargetSeeds(html: string) {
       continue;
     }
 
+    if (blockSeedCount >= 80) {
+      break;
+    }
+
     const id = `block-${blockIndex}`;
     seeds.push({
       id,
@@ -65,37 +277,68 @@ export function getPreviewTargetSeeds(html: string) {
       targetIndex: blockIndex
     });
     blockIndex += 1;
+    blockSeedCount += 1;
   }
 
-  const headingPattern = /<h([1-6])\b[^>]*>([\s\S]*?)<\/h\1>/gi;
-  let headingMatch: RegExpExecArray | null;
-  let headingIndex = 1;
+  const headingUnits = getPreviewHeadingUnits(html);
+  let headingSeedCount = 0;
 
-  while ((headingMatch = headingPattern.exec(bodyHtml)) && seeds.length < 120) {
-    const text = htmlToPlainText(headingMatch[2] ?? "");
+  for (const headingUnit of headingUnits) {
+    const text = htmlToPlainText(headingUnit.contentHtml);
 
     if (text.length < 2) {
-      headingIndex += 1;
       continue;
     }
 
-    const id = `heading-group-${headingIndex}`;
+    if (headingSeedCount >= 160) {
+      break;
+    }
+
+    const id = `heading-group-${headingUnit.targetIndex}`;
     seeds.push({
       id,
       kind: "heading_group",
       selector: getPreviewTargetSelector(id),
-      sourceHint: `H${headingMatch[1] ?? ""}`,
-      targetIndex: headingIndex
+      sourceHint: headingUnit.tagName.toLocaleUpperCase(),
+      targetIndex: headingUnit.targetIndex
     });
-    headingIndex += 1;
+    headingSeedCount += 1;
+  }
+
+  const textUnits = getPreviewAtomicTextUnits(html);
+  let textUnitSeedCount = 0;
+
+  for (const textUnit of textUnits) {
+    const text = htmlToPlainText(textUnit.contentHtml);
+
+    if (text.length >= 8) {
+      if (textUnitSeedCount >= 400) {
+        break;
+      }
+
+      const id = `text-unit-${textUnit.targetIndex}`;
+      seeds.push({
+        id,
+        kind: "text_unit",
+        selector: getPreviewTargetSelector(id),
+        sourceHint: `<${textUnit.tagName}>`,
+        targetIndex: textUnit.targetIndex
+      });
+      textUnitSeedCount += 1;
+    }
   }
 
   const mediaPattern = /<(img|video)\b([^>]*)>/gi;
   let mediaMatch: RegExpExecArray | null;
   let mediaIndex = 0;
-  while ((mediaMatch = mediaPattern.exec(bodyHtml)) && seeds.length < 180) {
+  let mediaSeedCount = 0;
+  while ((mediaMatch = mediaPattern.exec(bodyHtml))) {
     mediaIndex += 1;
 
+    if (mediaSeedCount >= 160) {
+      break;
+    }
+
     const tagName = mediaMatch[1] ?? "img";
     const attributes = mediaMatch[2] ?? "";
     const source = getAttribute(attributes, "src") ?? getAttribute(attributes, "poster");
@@ -107,20 +350,51 @@ export function getPreviewTargetSeeds(html: string) {
       sourceHint: source ?? `${tagName}:nth-of-type(${mediaIndex})`,
       targetIndex: mediaIndex
     });
+    mediaSeedCount += 1;
   }
 
   return seeds;
 }
 
 export function annotatePreviewTargets(html: string, seeds: PreviewTargetSeed[]) {
+  const protectedHtml = protectRawTextBlocks(html);
   const blockSeeds = seeds.filter((seed) => seed.kind === "content_block");
   const headingSeeds = seeds.filter((seed) => seed.kind === "heading_group");
+  const textUnitSeeds = seeds.filter((seed) => seed.kind === "text_unit");
   const mediaSeeds = seeds.filter((seed) => seed.kind === "media");
   let blockIndex = 0;
-  let headingIndex = 0;
   let mediaIndex = 0;
 
-  return html
+  const textElementAnnotations = [
+    ...getPreviewHeadingUnits(protectedHtml.html).map((unit) => ({ kind: "heading_group" as const, unit })),
+    ...getPreviewAtomicTextUnits(protectedHtml.html).map((unit) => ({ kind: "text_unit" as const, unit }))
+  ]
+    .flatMap(({ kind, unit }) => {
+      const text = htmlToPlainText(unit.contentHtml);
+      const eligible = kind === "heading_group" ? text.length >= 2 : text.length >= 8;
+      const candidates = kind === "heading_group" ? headingSeeds : textUnitSeeds;
+      const seed = eligible ? candidates.find((candidate) => candidate.targetIndex === unit.targetIndex) : null;
+
+      if (!seed) {
+        return [];
+      }
+
+      const openingTag = protectedHtml.html.slice(unit.documentSourceIndex, unit.openingTagEndIndex);
+      return [{
+        end: unit.openingTagEndIndex,
+        replacement: injectAttribute(openingTag, "data-seo-target-id", seed.id),
+        start: unit.documentSourceIndex
+      }];
+    })
+    .sort((left, right) => right.start - left.start);
+
+  let annotatedHtml = protectedHtml.html;
+
+  for (const annotation of textElementAnnotations) {
+    annotatedHtml = `${annotatedHtml.slice(0, annotation.start)}${annotation.replacement}${annotatedHtml.slice(annotation.end)}`;
+  }
+
+  const annotatedStructuralHtml = annotatedHtml
     .replace(/<(section|article|header|main|footer|aside|nav)\b([^>]*)>([\s\S]*?)<\/\1>/gi, (blockHtml, tagName: string, attributes: string, content: string) => {
       const text = htmlToPlainText(content);
 
@@ -138,27 +412,12 @@ export function annotatePreviewTargets(html: string, seeds: PreviewTargetSeed[])
       const openingTag = `<${tagName}${attributes}>`;
       return blockHtml.replace(openingTag, injectAttribute(openingTag, "data-seo-target-id", seed.id));
     })
-    .replace(/<h([1-6])\b([^>]*)>([\s\S]*?)<\/h\1>/gi, (headingHtml, level: string, attributes: string, content: string) => {
-      const text = htmlToPlainText(content);
-
-      if (text.length < 2) {
-        return headingHtml;
-      }
-
-      const seed = headingSeeds[headingIndex];
-      headingIndex += 1;
-
-      if (!seed) {
-        return headingHtml;
-      }
-
-      const openingTag = `<h${level}${attributes}>`;
-      return headingHtml.replace(openingTag, injectAttribute(openingTag, "data-seo-target-id", seed.id));
-    })
     .replace(/<(img|video)\b([^>]*)>/gi, (openingTag) => {
       mediaIndex += 1;
       const seed = mediaSeeds.find((candidate) => candidate.targetIndex === mediaIndex);
 
       return seed ? injectAttribute(openingTag, "data-seo-target-id", seed.id) : openingTag;
     });
+
+  return protectedHtml.restore(annotatedStructuralHtml);
 }
diff --git a/seo_mode/seo_mode/server/src/workspace/semanticBlocks.ts b/seo_mode/seo_mode/server/src/workspace/semanticBlocks.ts
index fc3c559..8c1d518 100644
--- a/seo_mode/seo_mode/server/src/workspace/semanticBlocks.ts
+++ b/seo_mode/seo_mode/server/src/workspace/semanticBlocks.ts
@@ -54,6 +54,11 @@ export type SemanticBlockModel = {
 };
 
 export type SemanticBlockSaveInput = {
+  replaceWorkspaces?: Array<{
+    pageId: string;
+    scopeId: string;
+    workspaceKey: string;
+  }>;
   scanVersionId?: string | null;
   workspaceKey: string;
   scopeId: string;
@@ -175,11 +180,18 @@ export async function listSemanticBlocksForPages(projectId: string, pageIds: str
       from semantic_blocks sb
       join pages p on p.id = sb.page_id and p.project_id = sb.project_id
       where sb.project_id = $1
-        and sb.page_id = any($2::uuid[])
+        and (
+          sb.page_id = any($2::uuid[])
+          or exists (
+            select 1
+            from jsonb_array_elements_text(coalesce(sb.identity -> 'memberPageIds', '[]'::jsonb)) as member_page_id(value)
+            where member_page_id.value = any($3::text[])
+          )
+        )
         and sb.archived_at is null
       order by sb.page_id asc, sb.workspace_key asc, sb.scope_id asc, sb.updated_at desc, sb.block_key asc;
     `,
-    [projectId, uniquePageIds]
+    [projectId, uniquePageIds, uniquePageIds]
   );
 
   return result.rows.map(mapSemanticBlockRow);
@@ -195,6 +207,23 @@ export async function saveSemanticBlocksForWorkspace(projectId: string, pageId:
     throw new SemanticBlockWorkspaceError("Нужны workspaceKey и scopeId для semantic blocks.");
   }
 
+  const replaceWorkspaces = Array.from(
+    new Map(
+      (input.replaceWorkspaces ?? [])
+        .map((entry) => ({
+          pageId: cleanText(entry.pageId, 80),
+          scopeId: cleanText(entry.scopeId, 240),
+          workspaceKey: cleanText(entry.workspaceKey, 240)
+        }))
+        .filter((entry) => entry.pageId && entry.scopeId && entry.workspaceKey)
+        .map((entry) => [`${entry.pageId}::${entry.workspaceKey}::${entry.scopeId}`, entry] as const)
+    ).values()
+  );
+
+  for (const entry of replaceWorkspaces) {
+    await assertPageBelongsToProject(projectId, entry.pageId);
+  }
+
   const normalizedBlocks = input.blocks
     .map((block) => ({
       anchors: normalizeArray(block.anchors),
@@ -217,19 +246,36 @@ export async function saveSemanticBlocksForWorkspace(projectId: string, pageId:
 
   await client.query("begin");
   try {
-    await client.query(
-      `
-        update semantic_blocks
-        set archived_at = now(), updated_at = now()
-        where project_id = $1
-          and page_id = $2
-          and workspace_key = $3
-          and scope_id = $4
-          and archived_at is null
-          and not (block_key = any($5::text[]));
-      `,
-      [projectId, pageId, workspaceKey, scopeId, blockKeys]
-    );
+    if (replaceWorkspaces.length > 0) {
+      for (const entry of replaceWorkspaces) {
+        await client.query(
+          `
+            update semantic_blocks
+            set archived_at = now(), updated_at = now()
+            where project_id = $1
+              and page_id = $2
+              and workspace_key = $3
+              and scope_id = $4
+              and archived_at is null;
+          `,
+          [projectId, entry.pageId, entry.workspaceKey, entry.scopeId]
+        );
+      }
+    } else {
+      await client.query(
+        `
+          update semantic_blocks
+          set archived_at = now(), updated_at = now()
+          where project_id = $1
+            and page_id = $2
+            and workspace_key = $3
+            and scope_id = $4
+            and archived_at is null
+            and not (block_key = any($5::text[]));
+        `,
+        [projectId, pageId, workspaceKey, scopeId, blockKeys]
+      );
+    }
 
     for (const block of normalizedBlocks) {
       await client.query(