A5-R3-R7-R1 English section structural ownership + seal continuity

core/generation_runner.py

@@ -917,6 +917,52 @@ class GenerationRunner:
             return ''
         return f"# {title}\n" + match.group(1).strip()
 
+    @staticmethod
+    def _normalize_orchestrator_owned_headings(text: str, task: dict) -> str:
+        """Restore immutable H1/H2 structure after any model-owned repair path.
+
+        Writer and repair models own prose only.  The orchestrator owns the
+        expected top-level and subsection headings described by the generation
+        task.  This deterministic normalizer removes only exact markdown
+        heading lines for those owned titles, then restores the canonical
+        heading(s) required for this unit.  All non-heading text is preserved.
+
+        The operation is intentionally idempotent: N(N(x)) == N(x).
+        """
+        value = str(text or "")
+        task = dict(task or {})
+        section_title = str(task.get("section") or "").strip()
+        subsection_title = str(task.get("subsection") or "").strip()
+        section_first = bool(task.get("section_first")) and bool(section_title)
+        subsection_first = bool(task.get("subsection_first")) and bool(subsection_title)
+
+        owned_titles = [title for title in (section_title, subsection_title) if title]
+        if not owned_titles:
+            return value
+
+        patterns = [
+            re.compile(rf"^[ \\t]*#{{1,6}}[ \\t]+{re.escape(title)}[ \\t]*$")
+            for title in owned_titles
+        ]
+        kept_lines = []
+        for line in value.splitlines(keepends=True):
+            visible = line.rstrip("\r\n")
+            if any(pattern.fullmatch(visible) for pattern in patterns):
+                continue
+            kept_lines.append(line)
+        body = "".join(kept_lines).lstrip("\r\n")
+
+        canonical = []
+        if section_first:
+            canonical.append(f"# {section_title}")
+        if subsection_first:
+            canonical.append(f"## {subsection_title}")
+        if not canonical:
+            return body
+
+        prefix = "\n\n".join(canonical)
+        return prefix if not body else prefix + "\n\n" + body
+
     @staticmethod
     def _english_prefix_through_top_level(manuscript: str, title: str) -> str:
         value = str(manuscript or '')
@@ -4629,6 +4675,21 @@ The previous attempt for this same manuscript unit was rejected by validation. R
                 state.pop("section_retry_exhausted", None)
                 break
 
+            # R7-R1: heading structure is orchestrator-owned, not model-owned.
+            # Any adaptive repair may replace the accepted prose bytes and drop
+            # or duplicate the system-inserted H1/H2. Restore only those exact
+            # structural anchors after the final model-owned repair and before
+            # the unit is appended to the immutable English source / Section Seal.
+            normalized_en_resolved = self._normalize_orchestrator_owned_headings(en_resolved, sec)
+            if normalized_en_resolved != en_resolved:
+                logging.info("Deterministic English heading normalization | unit=%s", display_name)
+                quality_diagnostics.append({
+                    "scope": "english_structural_ownership",
+                    "name": display_name,
+                    "status": "deterministic_heading_normalization",
+                })
+            en_resolved = normalized_en_resolved
+
             # Recompute citation survival/claim demand from the exact text that
             # will be sealed, not from an earlier pre-cleanup intermediate.
             if not is_quarantined and section_id in self._citation_eligible_section_ids(mode):