P0-R1.1-R2-R2 Shared Enumeration Scope Ownership

core/generation_runner.py

@@ -3104,11 +3104,11 @@ Output only final academic prose. Do not report the word count."""
                         if mode == "asq" else "final_quantitative_study_fact_contract_failed"
                     )
                     raise RuntimeError(f"{prefix}:{section_title}") from exc
-                enum_checked, _enum_rows = agent.repair_and_validate_enumeration_contract(
+                # Post-seal structural validation is pure validation.  Never
+                # invoke a mutating enumeration repair on frozen English text.
+                agent.validate_enumeration_contract(
                     sealed_section, section_name=f"Final sealed section: {section_title}"
                 )
-                if enum_checked.strip() != sealed_section.strip():
-                    raise RuntimeError(f"final_enumeration_contract_failed:{section_title}")
             # Validate the completed body while the Working Abstract is still in
             # place. Final front matter must not be generated until all body
             # sections, citation cleanup, and any Discussion rebalance are frozen.

core/pipeline_agent.py

@@ -3362,40 +3362,199 @@ INPUT:
             passages.extend(re.findall(pattern, str(value)))
         return [passage for passage in passages if len(passage.strip()) >= 8]
 
+    @staticmethod
+    def _enumeration_declaration_pattern():
+        return re.compile(
+            r"\b(?P<count>two|three|four|five|six|[2-6])\s+(?:provisional\s+)?"
+            r"(?P<noun>process\s+domains?|domains?|mechanisms?|dimensions?|stages?|patterns?|"
+            r"components?|themes?|processes?|conditions?)\b",
+            flags=re.I,
+        )
+
+    @staticmethod
+    def _enumeration_ordinal_pattern():
+        return re.compile(
+            r"\bThe\s+(?P<ordinal>first|second|third|fourth|fifth|sixth)\b"
+            r"(?:\s+(?P<noun>process\s+domain|domain|mechanism|dimension|stage|pattern|"
+            r"component|theme|process|condition)s?\b)?",
+            flags=re.I,
+        )
+
+    @staticmethod
+    def _enumeration_noun_family(value):
+        token = re.sub(r"\s+", " ", str(value or "")).strip().casefold()
+        if "domain" in token:
+            return "domain"
+        for family in ("mechanism", "dimension", "stage", "pattern", "component", "theme", "process", "condition"):
+            if family in token:
+                return family
+        return token
+
+    @classmethod
+    def _enumeration_group_records(cls, text):
+        """Return declaration-owned local ordinal runs without crossing list resets.
+
+        A declaration owns only the text before the next declaration/heading (and
+        at most 3500 characters).  Within that scope an ordinal reset/regression
+        starts a different list, so ``first ... first ... second`` is not flattened
+        into one synthetic enumeration.  This is intentionally conservative.
+        """
+        value = str(text or "")
+        decl = cls._enumeration_declaration_pattern()
+        ordinal = cls._enumeration_ordinal_pattern()
+        number_map = {"two":2, "three":3, "four":4, "five":5, "six":6,
+                      "2":2, "3":3, "4":4, "5":5, "6":6}
+        ordinal_map = {"first":1, "second":2, "third":3, "fourth":4, "fifth":5, "sixth":6}
+        declarations = list(decl.finditer(value))
+        groups = []
+        for index, match in enumerate(declarations):
+            start = match.end()
+            scope_end = min(len(value), start + 3500)
+            if index + 1 < len(declarations):
+                scope_end = min(scope_end, declarations[index + 1].start())
+            heading = re.search(r"\n#{1,3}\s+", value[start:scope_end])
+            if heading:
+                scope_end = min(scope_end, start + heading.start())
+            scope = value[start:scope_end]
+            declared_family = cls._enumeration_noun_family(match.group("noun"))
+            run = []
+            previous_num = None
+            for omatch in ordinal.finditer(scope):
+                num = ordinal_map[omatch.group("ordinal").casefold()]
+                explicit_family = cls._enumeration_noun_family(omatch.group("noun")) if omatch.group("noun") else ""
+                if explicit_family and explicit_family != declared_family:
+                    if run:
+                        break
+                    # The first visible ordinal explicitly belongs to another
+                    # enumeration family, so this declaration has no owned run.
+                    break
+                if previous_num is not None and num <= previous_num:
+                    # Restart/regression denotes a new/nested list. Never merge it
+                    # into the current declaration merely because it is nearby.
+                    break
+                run.append({
+                    "match": omatch,
+                    "number": num,
+                    "word": omatch.group("ordinal"),
+                    "abs_start": start + omatch.start("ordinal"),
+                    "abs_end": start + omatch.end("ordinal"),
+                })
+                previous_num = num
+            groups.append({
+                "declaration": match,
+                "immutable": cls._enumeration_context_is_immutable(value, match.start()),
+                "count": number_map[match.group("count").casefold()],
+                "count_surface": match.group("count"),
+                "noun": match.group("noun"),
+                "noun_family": declared_family,
+                "scope_start": start,
+                "scope_end": scope_end,
+                "run": run,
+                "numbers": [row["number"] for row in run],
+            })
+        return groups
+
+    @classmethod
+    def _enumeration_context_is_immutable(cls, text, position):
+        """Protect participant quotations and externally owned numbering."""
+        value = str(text or "")
+        pos = max(0, min(int(position or 0), len(value)))
+        block_start = value.rfind("\n\n", 0, pos) + 2
+        block_end = value.find("\n\n", pos)
+        if block_end < 0:
+            block_end = len(value)
+        block = value[block_start:block_end].strip()
+        if block.startswith(("\"", "“", ">")):
+            return True
+        for start, end, sentence in cls._sentence_spans(value):
+            if start <= pos <= end:
+                stripped = str(sentence or "").strip()
+                if stripped.startswith(("\"", "“", "‘", ">")):
+                    return True
+                if cls._has_external_literature_marker(sentence):
+                    return True
+                if re.search(
+                    r"(?i)\b(?:prior|previous|earlier|existing)\s+(?:research|stud(?:y|ies)|literature)\b",
+                    str(sentence or ""),
+                ):
+                    return True
+                break
+        return False
+
+    @staticmethod
+    def _enumeration_count_surface(old_surface, new_count):
+        words = {2:"two", 3:"three", 4:"four", 5:"five", 6:"six"}
+        old = str(old_surface or "")
+        if old.isdigit():
+            return str(new_count)
+        replacement = words.get(int(new_count), str(new_count))
+        if old[:1].isupper():
+            replacement = replacement.capitalize()
+        return replacement
+
     @classmethod
     def _repair_local_discourse_after_citation_removal(cls, original, audited, section_name=''):
-        """Repair only enumeration/ordinal framing after fail-closed sentence removal."""
+        """Repair only a declaration-owned enumeration damaged by sentence removal.
+
+        The old implementation globally renumbered every ``The first/second/...``
+        in the section, which could merge independent or nested lists.  A count is
+        now reduced only when the corresponding pre-audit declaration had a full
+        local run and the post-audit run demonstrably lost one or more items.
+        """
         before = str(original or '')
         value = str(audited or '')
         if not value or value == before:
             return value
-        ordinal_words = {'first':1, 'second':2, 'third':3, 'fourth':4, 'fifth':5, 'sixth':6}
-        ordinal_matches = list(re.finditer(r'\bThe\s+(first|second|third|fourth|fifth|sixth)\b', value, flags=re.I))
-        if len(ordinal_matches) < 2:
-            return value
-        nums = [ordinal_words[m.group(1).lower()] for m in ordinal_matches]
-        if nums == list(range(1, len(nums)+1)):
+        before_groups = cls._enumeration_group_records(before)
+        after_groups = cls._enumeration_group_records(value)
+        replacements = []
+        used_before = set()
+        reverse = {1:"first", 2:"second", 3:"third", 4:"fourth", 5:"fifth", 6:"sixth"}
+        for after in after_groups:
+            if after.get("immutable"):
+                continue
+            count = int(after["count"])
+            run = list(after["run"])
+            if not (2 <= len(run) < count):
+                continue
+            before_index = None
+            before_group = None
+            for idx, candidate in enumerate(before_groups):
+                if idx in used_before:
+                    continue
+                if (not candidate.get("immutable") and
+                        candidate["count"] == count and
+                        candidate["noun_family"] == after["noun_family"] and
+                        len(candidate["run"]) == count):
+                    before_index = idx
+                    before_group = candidate
+                    break
+            if before_group is None:
+                continue
+            # Require a complete pre-audit local run.  This proves that citation
+            # removal, rather than an originally incomplete/nested list, caused
+            # the missing ordinal item(s).
+            if before_group["numbers"] != list(range(1, count + 1)):
+                continue
+            used_before.add(before_index)
+            new_count = len(run)
+            decl_match = after["declaration"]
+            replacements.append((
+                decl_match.start("count"), decl_match.end("count"),
+                cls._enumeration_count_surface(after["count_surface"], new_count),
+            ))
+            for new_num, row in enumerate(run, start=1):
+                old_word = row["word"]
+                new_word = reverse[new_num]
+                if old_word[:1].isupper():
+                    new_word = new_word.capitalize()
+                if new_word.casefold() != old_word.casefold():
+                    replacements.append((row["abs_start"], row["abs_end"], new_word))
+        if not replacements:
             return value
-        words = {1:'first',2:'second',3:'third',4:'fourth',5:'fifth',6:'sixth'}
-        index = 0
-        def repl(match):
-            nonlocal index
-            index += 1
-            return 'The ' + words[index]
-        repaired = re.sub(r'\bThe\s+(?:first|second|third|fourth|fifth|sixth)\b', repl, value, flags=re.I)
-        count_words = {'two':2,'three':3,'four':4,'five':5,'six':6}
-        reverse = {2:'two',3:'three',4:'four',5:'five',6:'six'}
-        def count_repl(match):
-            old_n = count_words.get(match.group(1).lower(), 0)
-            noun = match.group(2)
-            if old_n >= max(nums) and len(nums) in reverse:
-                return f"{reverse[len(nums)]} {noun}"
-            return match.group(0)
-        repaired = re.sub(
-            r'\b(two|three|four|five|six)\s+(process\s+domains?|mechanisms?|dimensions?|stages?|patterns?|components?)\b',
-            count_repl, repaired, flags=re.I,
-        )
-        return repaired
+        for start, end, replacement in sorted(replacements, reverse=True):
+            value = value[:start] + replacement + value[end:]
+        return value
 
     @staticmethod
     def _qual_source_family(value):
@@ -3688,59 +3847,73 @@ INPUT:
             raise RuntimeError(f"qualitative_study_fact_contract_unrepaired:{section_name}:{diagnostics[:3]}")
         return True
 
+    @classmethod
+    def validate_enumeration_contract(cls, text, section_name=""):
+        """Validate only unambiguous declaration-owned local enumeration runs.
+
+        Incomplete, nested, restarted, or adjacent independent lists are not a
+        whole-manuscript failure condition.  They are deliberately outside the
+        deterministic repair boundary because ownership is ambiguous.
+        """
+        for group in cls._enumeration_group_records(text):
+            if group.get("immutable"):
+                continue
+            count = int(group["count"])
+            nums = list(group["numbers"])
+            if len(nums) != count:
+                continue
+            expected = list(range(1, count + 1))
+            if nums != expected:
+                raise RuntimeError(
+                    f"enumeration_contract_unresolved:{section_name}:"
+                    f"owner={group['noun_family']}:declared={count}:ordinals={nums}"
+                )
+        return True
+
     @classmethod
     def repair_and_validate_enumeration_contract(cls, text, section_name=""):
-        """Repair only high-confidence ordinal shifts tied to an explicit count."""
+        """Repair only a complete, declaration-owned local ordinal run.
+
+        A run may be renumbered by order only when exactly the declared number
+        of strictly increasing ordinal markers belongs to that declaration.
+        Resets such as ``[1, 1, 2]`` mark a second/nested list and are therefore
+        non-blocking rather than flattened into one synthetic sequence.
+        """
         value = str(text or "")
-        number_map = {"two":2, "three":3, "four":4, "five":5, "six":6, "2":2, "3":3, "4":4, "5":5, "6":6}
-        ordinal_map = {"first":1, "second":2, "third":3, "fourth":4, "fifth":5, "sixth":6}
-        reverse = {1:"first",2:"second",3:"third",4:"fourth",5:"fifth",6:"sixth"}
-        decl = re.compile(
-            r"\b(two|three|four|five|six|[2-6])\s+(?:provisional\s+)?"
-            r"(domains?|mechanisms?|dimensions?|stages?|patterns?|components?|themes?|processes?|conditions?)\b",
-            flags=re.I,
-        )
-        offset = 0
+        reverse = {1:"first", 2:"second", 3:"third", 4:"fourth", 5:"fifth", 6:"sixth"}
         diagnostics = []
-        for match in list(decl.finditer(value)):
-            count = number_map[match.group(1).lower()]
-            start = match.end() + offset
-            next_heading = re.search(r"\n#{1,3}\s+", value[start:])
-            scope_end = start + min(3500, next_heading.start() if next_heading else 3500)
-            scope = value[start:scope_end]
-            ordinals = list(re.finditer(r"\bThe\s+(first|second|third|fourth|fifth|sixth)\b", scope, flags=re.I))
-            if len(ordinals) < count:
+        replacements = []
+        for group in cls._enumeration_group_records(value):
+            if group.get("immutable"):
+                continue
+            count = int(group["count"])
+            run = list(group["run"])
+            nums = list(group["numbers"])
+            if len(run) != count:
+                # Ambiguous/incomplete/multiple-list scope: preserve authorial
+                # prose and let later reader-facing QA treat it as diagnostic.
                 continue
-            selected = ordinals[:count]
-            nums = [ordinal_map[m.group(1).lower()] for m in selected]
             expected = list(range(1, count + 1))
             if nums == expected:
                 continue
-            consecutive = nums == list(range(nums[0], nums[0] + count))
-            if not consecutive:
-                raise RuntimeError(f"enumeration_contract_mismatch:{section_name}:declared={count}:ordinals={nums}")
-            scope_chars = list(scope)
-            for index, omatch in reversed(list(enumerate(selected, start=1))):
-                old = omatch.group(1)
-                new = reverse[index]
-                if old[:1].isupper():
-                    new = new.capitalize()
-                a, b = omatch.start(1), omatch.end(1)
-                scope_chars[a:b] = list(new)
-            repaired_scope = "".join(scope_chars)
-            value = value[:start] + repaired_scope + value[scope_end:]
-            delta = len(repaired_scope) - len(scope)
-            offset += delta
-            diagnostics.append({"declared":count, "observed":nums, "repaired":expected})
-        # Validate the same high-confidence patterns after repair.
-        for match in decl.finditer(value):
-            count = number_map[match.group(1).lower()]
-            start = match.end()
-            next_heading = re.search(r"\n#{1,3}\s+", value[start:])
-            scope_end = start + min(3500, next_heading.start() if next_heading else 3500)
-            nums = [ordinal_map[m.group(1).lower()] for m in list(re.finditer(r"\bThe\s+(first|second|third|fourth|fifth|sixth)\b", value[start:scope_end], flags=re.I))[:count]]
-            if len(nums) >= count and nums != list(range(1, count + 1)):
-                raise RuntimeError(f"enumeration_contract_unresolved:{section_name}:declared={count}:ordinals={nums}")
+            # _enumeration_group_records stops at any reset/regression, so a
+            # complete run here is strictly increasing and safe to renumber by
+            # local order (e.g. 3/4/5 -> 1/2/3).
+            for new_num, row in enumerate(run, start=1):
+                old_word = row["word"]
+                new_word = reverse[new_num]
+                if old_word[:1].isupper():
+                    new_word = new_word.capitalize()
+                if new_word.casefold() != old_word.casefold():
+                    replacements.append((row["abs_start"], row["abs_end"], new_word))
+            diagnostics.append({
+                "declared": count, "owner": group["noun_family"],
+                "observed": nums, "repaired": expected,
+            })
+        if replacements:
+            for start, end, replacement in sorted(replacements, reverse=True):
+                value = value[:start] + replacement + value[end:]
+        cls.validate_enumeration_contract(value, section_name=section_name)
         return value, diagnostics
 
     @classmethod