Update docx, pptx, and xlsx skills (#1447)

Add support for template formats (.dotx, .potx, .xltx) across validation and the helper scripts. Consolidate the shared office helpers into a single module, replacing the pack/unpack pipeline with explicit zip/unzip steps. Extraction now rejects symlink and path-traversal archive entries. Move run merging to a standalone docx script, since it only ever applied to Word documents. Fix the redlining validator so it compares against the original even when a document has no tracked changes, which is when an untracked edit would otherwise go unreported. Provision a LibreOffice user profile per invocation so conversions work in sandboxed environments. Trim the skill docs to the guidance that earns its place.
2026-08-02 21:15:27 +08:00 · 2026-07-16 19:47:37 -07:00
parent 9d2f1ae187
commit fa0fa64bdc
53 changed files with 4147 additions and 4442 deletions
@@ -6,8 +6,20 @@ import re
 from pathlib import Path

 import defusedxml.minidom
+from functools import lru_cache
+
 import lxml.etree

+from helpers import safe_extract
+
+
+@lru_cache(maxsize=None)
+def _load_schema(schema_path: str):
+    with open(schema_path, "rb") as xsd_file:
+        xsd_doc = lxml.etree.parse(
+            xsd_file, parser=lxml.etree.XMLParser(), base_url=schema_path
+        )
+    return lxml.etree.XMLSchema(xsd_doc)

 class BaseSchemaValidator:

@@ -119,21 +131,28 @@ class BaseSchemaValidator:
            try:
                content = xml_file.read_text(encoding="utf-8")
                dom = defusedxml.minidom.parseString(content)
-                modified = False
+                pending = []  

                for elem in dom.getElementsByTagName("*"):
-                    if elem.tagName.endswith(":t") and elem.firstChild:
-                        text = elem.firstChild.nodeValue
-                        if text and (text.startswith((' ', '\t')) or text.endswith((' ', '\t'))):
+                    local_name = elem.tagName.rsplit(":", 1)[-1]
+                    if local_name in ("t", "delText", "instrText", "delInstrText"):
+                        text = "".join(
+                            child.data
+                            for child in elem.childNodes
+                            if child.nodeType in (child.TEXT_NODE, child.CDATA_SECTION_NODE)
+                        )
+                        ws = (" ", "\t", "\n", "\r")
+                        if text and (text.startswith(ws) or text.endswith(ws)):
                            if elem.getAttribute("xml:space") != "preserve":
                                elem.setAttribute("xml:space", "preserve")
                                text_preview = repr(text[:30]) + "..." if len(text) > 30 else repr(text)
-                                print(f"  Repaired: {xml_file.name}: Added xml:space='preserve' to {elem.tagName}: {text_preview}")
-                                repairs += 1
-                                modified = True
+                                pending.append(f"  Repaired: {xml_file.name}: Added xml:space='preserve' to {elem.tagName}: {text_preview}")

-                if modified:
+                if pending:
                    xml_file.write_bytes(dom.toxml(encoding="UTF-8"))
+                    for message in pending:
+                        print(message)
+                    repairs += len(pending)

            except Exception:
                pass
@@ -212,6 +231,8 @@ class BaseSchemaValidator:
                    elem.getparent().remove(elem)

                for elem in root.iter():
+                    if not hasattr(elem, "tag") or callable(elem.tag):
+                        continue
                    tag = (
                        elem.tag.split("}")[-1].lower()
                        if "}" in elem.tag
@@ -326,6 +347,8 @@ class BaseSchemaValidator:
                    namespaces={"ns": self.PACKAGE_RELATIONSHIPS_NAMESPACE},
                ):
                    target = rel.get("Target")
+                    if rel.get("TargetMode") == "External":
+                        continue
                    if target and not target.startswith(
                        ("http", "mailto:")
                    ):  
@@ -423,6 +446,8 @@ class BaseSchemaValidator:
                r_ns = self.OFFICE_RELATIONSHIPS_NAMESPACE
                rid_attrs_to_check = ["id", "embed", "link"]
                for elem in xml_root.iter():
+                    if not hasattr(elem, "tag") or callable(elem.tag):
+                        continue
                    for attr_name in rid_attrs_to_check:
                        rid_attr = elem.get(f"{{{r_ns}}}{attr_name}")
                        if not rid_attr:
@@ -747,18 +772,16 @@ class BaseSchemaValidator:

        return xml_doc

-    def _validate_single_file_xsd(self, xml_file, base_path):
-        schema_path = self._get_schema_path(xml_file)
+    def _preprocess_for_schema(self, xml_doc, relative_path):
+        return xml_doc
+
+    def _validate_single_file_xsd(self, xml_file, base_path, schema_path=None):
+        schema_path = schema_path or self._get_schema_path(xml_file)
        if not schema_path:
            return None, None  

        try:
-            with open(schema_path, "rb") as xsd_file:
-                parser = lxml.etree.XMLParser()
-                xsd_doc = lxml.etree.parse(
-                    xsd_file, parser=parser, base_url=str(schema_path)
-                )
-                schema = lxml.etree.XMLSchema(xsd_doc)
+            schema = _load_schema(str(schema_path))

            with open(xml_file, "r") as f:
                xml_doc = lxml.etree.parse(f)
@@ -773,6 +796,8 @@ class BaseSchemaValidator:
            ):
                xml_doc = self._clean_ignorable_namespaces(xml_doc)

+            xml_doc = self._preprocess_for_schema(xml_doc, relative_path)
+
            if schema.validate(xml_doc):
                return True, set()
            else:
@@ -784,7 +809,7 @@ class BaseSchemaValidator:
        except Exception as e:
            return False, {str(e)}

-    def _get_original_file_errors(self, xml_file):
+    def _get_original_file_errors(self, xml_file, schema_path=None):
        if self.original_file is None:
            return set()

@@ -798,8 +823,11 @@ class BaseSchemaValidator:
        with tempfile.TemporaryDirectory() as temp_dir:
            temp_path = Path(temp_dir)

-            with zipfile.ZipFile(self.original_file, "r") as zip_ref:
-                zip_ref.extractall(temp_path)
+            try:
+                with zipfile.ZipFile(self.original_file, "r") as zip_ref:
+                    safe_extract(zip_ref, temp_path)
+            except (zipfile.BadZipFile, ValueError, OSError):
+                return set()

            original_xml_file = temp_path / relative_path

@@ -807,7 +835,7 @@ class BaseSchemaValidator:
                return set()

            is_valid, errors = self._validate_single_file_xsd(
-                original_xml_file, temp_path
+                original_xml_file, temp_path, schema_path=schema_path
            )
            return errors if errors else set()

@@ -6,10 +6,13 @@ import random
 import re
 import tempfile
 import zipfile
+from pathlib import Path

 import defusedxml.minidom
 import lxml.etree

+from helpers import safe_extract
+
 from .base import BaseSchemaValidator


@@ -186,7 +189,7 @@ class DOCXSchemaValidator(BaseSchemaValidator):
        try:
            with tempfile.TemporaryDirectory() as temp_dir:
                with zipfile.ZipFile(original, "r") as zip_ref:
-                    zip_ref.extractall(temp_dir)
+                    safe_extract(zip_ref, Path(temp_dir))

                doc_xml_path = temp_dir + "/word/document.xml"
                root = lxml.etree.parse(doc_xml_path).getroot()
@@ -241,9 +244,12 @@ class DOCXSchemaValidator(BaseSchemaValidator):
            return True

    def compare_paragraph_counts(self):
-        original_count = self.count_paragraphs_in_original()
        new_count = self.count_paragraphs_in_unpacked()
+        if self.original_file is None:
+            print(f"\nParagraphs: {new_count}")
+            return

+        original_count = self.count_paragraphs_in_original()
        diff = new_count - original_count
        diff_str = f"+{diff}" if diff > 0 else str(diff)
        print(f"\nParagraphs: {original_count} → {new_count} ({diff_str})")
@@ -260,9 +266,15 @@ class DOCXSchemaValidator(BaseSchemaValidator):
            try:
                for elem in lxml.etree.parse(str(xml_file)).iter():
                    if val := elem.get(para_id_attr):
-                        if self._parse_id_value(val, base=16) >= 0x80000000:
+                        try:
+                            if self._parse_id_value(val, base=16) >= 0x80000000:
+                                errors.append(
+                                    f"  {xml_file.name}:{elem.sourceline}: paraId={val} >= 0x80000000"
+                                )
+                        except ValueError:
                            errors.append(
-                                f"  {xml_file.name}:{elem.sourceline}: paraId={val} >= 0x80000000"
+                                f"  {xml_file.name}:{elem.sourceline}: "
+                                f"paraId={val} is not valid hex"
                            )

                    if val := elem.get(durable_id_attr):
@@ -279,13 +291,19 @@ class DOCXSchemaValidator(BaseSchemaValidator):
                                    f"durableId={val} must be decimal in numbering.xml"
                                )
                        else:
-                            if self._parse_id_value(val, base=16) >= 0x7FFFFFFF:
+                            try:
+                                if self._parse_id_value(val, base=16) >= 0x7FFFFFFF:
+                                    errors.append(
+                                        f"  {xml_file.name}:{elem.sourceline}: "
+                                        f"durableId={val} >= 0x7FFFFFFF"
+                                    )
+                            except ValueError:
                                errors.append(
                                    f"  {xml_file.name}:{elem.sourceline}: "
-                                    f"durableId={val} >= 0x7FFFFFFF"
+                                    f"durableId={val} is not valid hex"
                                )
-            except Exception:
-                pass
+            except lxml.etree.XMLSyntaxError:
+                continue  

        if errors:
            print(f"FAILED - {len(errors)} ID constraint violations:")
@@ -389,52 +407,54 @@ class DOCXSchemaValidator(BaseSchemaValidator):
        return repairs

    def repair_durableId(self) -> int:
+        DURABLE_ID_ATTRS = ("w16cid:durableId", "w16cex:durableId")
        repairs = 0
+        renames: dict = {}  

        for xml_file in self.xml_files:
            try:
                content = xml_file.read_text(encoding="utf-8")
                dom = defusedxml.minidom.parseString(content)
+                is_numbering = xml_file.name == "numbering.xml"
+                base = 10 if is_numbering else 16
+                pending = []  
+                seen_in_file = set()
                modified = False

                for elem in dom.getElementsByTagName("*"):
-                    if not elem.hasAttribute("w16cid:durableId"):
-                        continue
+                    for attr_name in DURABLE_ID_ATTRS:
+                        if not elem.hasAttribute(attr_name):
+                            continue

-                    durable_id = elem.getAttribute("w16cid:durableId")
-                    needs_repair = False
-
-                    if xml_file.name == "numbering.xml":
+                        durable_id = elem.getAttribute(attr_name)
                        try:
-                            needs_repair = (
-                                self._parse_id_value(durable_id, base=10) >= 0x7FFFFFFF
-                            )
-                        except ValueError:
-                            needs_repair = True
-                    else:
-                        try:
-                            needs_repair = (
-                                self._parse_id_value(durable_id, base=16) >= 0x7FFFFFFF
-                            )
+                            key = self._parse_id_value(durable_id, base=base)
+                            needs_repair = key >= 0x7FFFFFFF
                        except ValueError:
+                            key = durable_id
                            needs_repair = True

-                    if needs_repair:
-                        value = random.randint(1, 0x7FFFFFFE)
-                        if xml_file.name == "numbering.xml":
-                            new_id = str(value)  
-                        else:
-                            new_id = f"{value:08X}"  
+                        if needs_repair:
+                            if key in seen_in_file:
+                                value = random.randint(1, 0x7FFFFFFE)
+                            else:
+                                seen_in_file.add(key)
+                                if key not in renames:
+                                    renames[key] = random.randint(1, 0x7FFFFFFE)
+                                value = renames[key]
+                            new_id = str(value) if is_numbering else f"{value:08X}"

-                        elem.setAttribute("w16cid:durableId", new_id)
-                        print(
-                            f"  Repaired: {xml_file.name}: durableId {durable_id} → {new_id}"
-                        )
-                        repairs += 1
-                        modified = True
+                            elem.setAttribute(attr_name, new_id)
+                            pending.append(
+                                f"  Repaired: {xml_file.name}: durableId {durable_id} → {new_id}"
+                            )
+                            modified = True

                if modified:
                    xml_file.write_bytes(dom.toxml(encoding="UTF-8"))
+                    for message in pending:
+                        print(message)
+                    repairs += len(pending)

            except Exception:
                pass
@@ -3,6 +3,9 @@ Validator for PowerPoint presentation XML files against XSD schemas.
 """

 import re
+from pathlib import Path
+
+from helpers import opc_target, rels_source_part, safe_extract

 from .base import BaseSchemaValidator

@@ -57,8 +60,171 @@ class PPTXSchemaValidator(BaseSchemaValidator):
        if not self.validate_no_duplicate_slide_layouts():
            all_valid = False

+        if not self.validate_master_theme_uniqueness():
+            all_valid = False
+
+        if not self.validate_charts():
+            all_valid = False
+
+        if not self.validate_slides():
+            all_valid = False
+
        return all_valid

+    def _package_map(self) -> dict:
+        wanted = []
+        wanted += list(self.unpacked_dir.glob("[[]Content_Types[]].xml"))
+        wanted += list(self.unpacked_dir.glob("ppt/presentation.xml"))
+        wanted += list(self.unpacked_dir.glob("ppt/theme/*.xml"))
+        wanted += list(self.unpacked_dir.glob("ppt/theme/_rels/*.rels"))
+        wanted += list(self.unpacked_dir.glob("ppt/charts/chart*.xml"))
+        for group in ("slideMasters", "notesMasters", "handoutMasters"):
+            wanted += list(self.unpacked_dir.glob(f"ppt/{group}/*.xml"))
+            wanted += list(self.unpacked_dir.glob(f"ppt/{group}/_rels/*.rels"))
+        return {
+            p.relative_to(self.unpacked_dir).as_posix(): p.read_bytes()
+            for p in wanted
+            if p.is_file()
+        }
+
+    def validate_master_theme_uniqueness(self):
+        from helpers.pptx_theme import _NOTES_MASTERS, live_shared_master_themes
+
+        shared = live_shared_master_themes(self._package_map())
+        if shared:
+            print(f"FAILED - Found {len(shared)} master(s) sharing a theme part:")
+            for message in shared:
+                print(f"  {message}")
+            if any(m.startswith(_NOTES_MASTERS) for m in shared):
+                print("  Fix: in ppt/presentation.xml, move <p:notesMasterIdLst> back to "
+                      "directly after <p:sldIdLst>. PowerPoint reads that happily.")
+            else:
+                print("  Fix: give each master its own theme part.")
+            return False
+
+        if self.verbose:
+            print("PASSED - No master shares a theme part in a way PowerPoint refuses")
+        return True
+
+    def validate_charts(self):
+        from helpers.pptx_chart import find_chart_problems
+
+        problems = find_chart_problems(self._package_map())
+        if problems:
+            print(f"FAILED - Found {len(problems)} chart problem(s) PowerPoint rejects:")
+            for message in problems:
+                print(f"  {message}")
+            return False
+
+        if self.verbose:
+            print("PASSED - Charts satisfy the constraints PowerPoint enforces")
+        return True
+
+    def _original_slide_defects(self, schema) -> set[str]:
+        import tempfile
+        import zipfile
+
+        from helpers.pptx_slide import SLIDE_PART_RE, fatal_slide_errors
+
+        if self.original_file is None:
+            return set()
+
+        found: set[str] = set()
+        with tempfile.TemporaryDirectory() as temp_dir:
+            temp_path = Path(temp_dir)
+            try:
+                with zipfile.ZipFile(self.original_file, "r") as zf:
+                    safe_extract(zf, temp_path)
+            except (zipfile.BadZipFile, ValueError, OSError):
+                return set()  
+
+            for part in sorted(temp_path.rglob("*.xml")):
+                relative = part.relative_to(temp_path).as_posix()
+                if not SLIDE_PART_RE.fullmatch(relative):
+                    continue
+                ok, errors = self._validate_single_file_xsd(
+                    part.resolve(), temp_path.resolve(), schema_path=schema
+                )
+                if ok is None or ok or not errors:
+                    continue
+                found |= set(fatal_slide_errors(set(errors)))
+        return found
+
+    def validate_slides(self):
+        from helpers.pptx_slide import (
+            SLIDE_PART_RE,
+            fatal_slide_errors,
+            is_schema_verdict,
+        )
+
+        schema = self.schemas_dir / self.SCHEMA_MAPPINGS["ppt"]
+        inherited = self._original_slide_defects(schema)
+        problems: list[str] = []
+        broken: list[str] = []
+
+        for xml_file in self.xml_files:
+            relative = xml_file.relative_to(self.unpacked_dir).as_posix()
+            if not SLIDE_PART_RE.fullmatch(relative):
+                continue
+            ok, errors = self._validate_single_file_xsd(
+                xml_file.resolve(), self.unpacked_dir.resolve(), schema_path=schema
+            )
+            if ok is None or not errors:
+                continue
+
+            unreadable = [f"{relative}: {e}" for e in errors if not is_schema_verdict(e)]
+            if unreadable:
+                broken.extend(unreadable)
+                continue
+            if ok:
+                continue
+
+            for message in fatal_slide_errors(set(errors)):
+                if message in inherited:
+                    continue  
+                problems.append(f"{relative}: {message}")
+
+        if broken:
+            print(f"FAILED - Could not check {len(broken)} slide part(s):")
+            for message in sorted(broken):
+                print(f"  {message[:240]}")
+
+        if problems:
+            print(f"FAILED - Found {len(problems)} slide problem(s) PowerPoint rejects:")
+            for message in sorted(problems):
+                print(f"  {message[:240]}")
+
+        if broken or problems:
+            return False
+
+        if self.verbose:
+            print("PASSED - Slide XML has none of the defects PowerPoint refuses")
+        return True
+
+    def _get_schema_path(self, xml_file):
+        if xml_file.parent.name == "charts" and xml_file.name.startswith("chart"):
+            return None
+        return super()._get_schema_path(xml_file)
+
+    def _preprocess_for_schema(self, xml_doc, relative_path):
+        if relative_path.as_posix() != "ppt/presentation.xml":
+            return xml_doc
+
+        root = xml_doc.getroot()
+        ns = f"{{{self.PRESENTATIONML_NAMESPACE}}}"
+        notes = root.find(f"{ns}notesMasterIdLst")
+        slides = root.find(f"{ns}sldIdLst")
+        if notes is None or slides is None:
+            return xml_doc
+
+        children = list(root)
+        if children.index(notes) < children.index(slides):
+            return xml_doc  
+
+        root.remove(notes)
+        root.insert(list(root).index(slides), notes)
+        return xml_doc
+
    def validate_uuid_ids(self):
        import lxml.etree

@@ -229,17 +395,17 @@ class PPTXSchemaValidator(BaseSchemaValidator):
                ):
                    rel_type = rel.get("Type", "")
                    if "notesSlide" in rel_type:
-                        target = rel.get("Target", "")
-                        if target:
-                            normalized_target = target.replace("../", "")
-
+                        part = opc_target(
+                            rel.get("Target", ""),
+                            rels_source_part(rels_file, self.unpacked_dir),
+                            rel.get("TargetMode", ""),
+                        )
+                        if part:
                            slide_name = rels_file.stem.replace(
                                ".xml", ""
                            )  

-                            if normalized_target not in notes_slide_references:
-                                notes_slide_references[normalized_target] = []
-                            notes_slide_references[normalized_target].append(
+                            notes_slide_references.setdefault(part, []).append(
                                (slide_name, rels_file)
                            )

@@ -1,5 +1,14 @@
 """
 Validator for tracked changes in Word documents.
+
+Detects untracked edits in word/document.xml: text that differs from the
+original without a <w:ins>/<w:del> wrapper recording it. The tracked changes
+that are new relative to the original are undone, and the result is compared
+against the original; whatever text still differs was edited without being
+tracked.
+
+Only the document body is compared. Headers, footers, footnotes and endnotes
+are separate parts and are not checked.
 """

 import subprocess
@@ -7,14 +16,18 @@ import tempfile
 import zipfile
 from pathlib import Path

+import defusedxml.ElementTree as ET
+from defusedxml.common import DefusedXmlException
+
+from helpers import rendered_text, safe_extract
+

 class RedliningValidator:

-    def __init__(self, unpacked_dir, original_docx, verbose=False, author="Claude"):
+    def __init__(self, unpacked_dir, original_docx, verbose=False):
        self.unpacked_dir = Path(unpacked_dir)
        self.original_docx = Path(original_docx)
        self.verbose = verbose
-        self.author = author
        self.namespaces = {
            "w": "http://schemas.openxmlformats.org/wordprocessingml/2006/main"
        }
@@ -28,40 +41,12 @@ class RedliningValidator:
            print(f"FAILED - Modified document.xml not found at {modified_file}")
            return False

-        try:
-            import xml.etree.ElementTree as ET
-
-            tree = ET.parse(modified_file)
-            root = tree.getroot()
-
-            del_elements = root.findall(".//w:del", self.namespaces)
-            ins_elements = root.findall(".//w:ins", self.namespaces)
-
-            author_del_elements = [
-                elem
-                for elem in del_elements
-                if elem.get(f"{{{self.namespaces['w']}}}author") == self.author
-            ]
-            author_ins_elements = [
-                elem
-                for elem in ins_elements
-                if elem.get(f"{{{self.namespaces['w']}}}author") == self.author
-            ]
-
-            if not author_del_elements and not author_ins_elements:
-                if self.verbose:
-                    print(f"PASSED - No tracked changes by {self.author} found.")
-                return True
-
-        except Exception:
-            pass
-
        with tempfile.TemporaryDirectory() as temp_dir:
            temp_path = Path(temp_dir)

            try:
                with zipfile.ZipFile(self.original_docx, "r") as zip_ref:
-                    zip_ref.extractall(temp_path)
+                    safe_extract(zip_ref, temp_path)
            except Exception as e:
                print(f"FAILED - Error unpacking original docx: {e}")
                return False
@@ -74,18 +59,16 @@ class RedliningValidator:
                return False

            try:
-                import xml.etree.ElementTree as ET
-
                modified_tree = ET.parse(modified_file)
                modified_root = modified_tree.getroot()
                original_tree = ET.parse(original_file)
                original_root = original_tree.getroot()
-            except ET.ParseError as e:
+            except (ET.ParseError, DefusedXmlException) as e:
                print(f"FAILED - Error parsing XML files: {e}")
                return False

-            self._remove_author_tracked_changes(original_root)
-            self._remove_author_tracked_changes(modified_root)
+            new_changes = self._new_tracked_changes(original_root, modified_root)
+            self._remove_tracked_changes(modified_root, new_changes)

            modified_text = self._extract_text_content(modified_root)
            original_text = self._extract_text_content(original_root)
@@ -98,20 +81,91 @@ class RedliningValidator:
                return False

            if self.verbose:
-                print(f"PASSED - All changes by {self.author} are properly tracked")
+                print(
+                    f"PASSED - All {len(new_changes)} change(s) against the original "
+                    "are properly tracked"
+                )
            return True

+    def _tracked_change_elements(self, root):
+        ins_tag = f"{{{self.namespaces['w']}}}ins"
+        del_tag = f"{{{self.namespaces['w']}}}del"
+        return [elem for elem in root.iter() if elem.tag in (ins_tag, del_tag)]
+
+    def _rendered_text(self, elem):
+        preserve = elem.get("{http://www.w3.org/XML/1998/namespace}space") == "preserve"
+        return rendered_text(elem.text or "", preserve)
+
+    def _text_elements(self, elem):
+        w = self.namespaces["w"]
+        return [
+            node
+            for node in elem.iter()
+            if node.tag in (f"{{{w}}}t", f"{{{w}}}delText")
+        ]
+
+    def _tracked_change_key(self, elem):
+        w = self.namespaces["w"]
+        text = "".join(self._rendered_text(node) for node in self._text_elements(elem))
+        return (elem.tag, elem.get(f"{{{w}}}author"), elem.get(f"{{{w}}}date"), text)
+
+    def _new_tracked_changes(self, original_root, modified_root):
+        original = self._tracked_change_elements(original_root)
+        modified = self._tracked_change_elements(modified_root)
+
+        pool = {}
+        for elem in original:
+            pool.setdefault(self._tracked_change_key(elem), []).append(elem)
+
+        matched, leftover = set(), []
+        for elem in modified:
+            bucket = pool.get(self._tracked_change_key(elem))
+            if bucket:
+                matched.add(bucket.pop())
+            else:
+                leftover.append(elem)
+
+        def group(elem):
+            return self._tracked_change_key(elem)[:3]
+
+        def text_of(elems):
+            return "".join(self._tracked_change_key(e)[3] for e in elems)
+
+        unmatched_original = {}
+        for elem in original:
+            if elem not in matched:
+                unmatched_original.setdefault(group(elem), []).append(elem)
+
+        by_group = {}
+        for elem in leftover:
+            by_group.setdefault(group(elem), []).append(elem)
+
+        new = set()
+        for key, elems in by_group.items():
+            rebuilt = text_of(elems)
+            if rebuilt and rebuilt == text_of(unmatched_original.get(key, [])):
+                continue  
+            new.update(elems)
+        return new
+
    def _generate_detailed_diff(self, original_text, modified_text):
        error_parts = [
-            f"FAILED - Document text doesn't match after removing {self.author}'s tracked changes",
+            "FAILED - Document text doesn't match after removing the tracked changes",
            "",
            "Likely causes:",
            "  1. Modified text inside another author's <w:ins> or <w:del> tags",
            "  2. Made edits without proper tracked changes",
            "  3. Didn't nest <w:del> inside <w:ins> when deleting another's insertion",
+            "  4. Rewrote another author's <w:ins>/<w:del> and changed its text on",
+            "     the way. A tracked change from the original is recognised by its",
+            "     author, date and text; anything that doesn't reproduce one exactly",
+            "     reads as new, and the text it carried is reported missing.",
            "",
            "For pre-redlined documents, use correct patterns:",
            "  - To reject another's INSERTION: Nest <w:del> inside their <w:ins>",
+            "  - To reject PART of one: nest <w:del> around only the runs you reject.",
+            "    Their <w:ins> may be split around it, so long as the pieces keep",
+            "    their author and date and still spell out the same text.",
            "  - To restore another's DELETION: Add new <w:ins> AFTER their <w:del>",
            "",
        ]
@@ -195,15 +249,14 @@ class RedliningValidator:

        return None

-    def _remove_author_tracked_changes(self, root):
+    def _remove_tracked_changes(self, root, targets):
        ins_tag = f"{{{self.namespaces['w']}}}ins"
        del_tag = f"{{{self.namespaces['w']}}}del"
-        author_attr = f"{{{self.namespaces['w']}}}author"

        for parent in root.iter():
            to_remove = []
            for child in parent:
-                if child.tag == ins_tag and child.get(author_attr) == self.author:
+                if child.tag == ins_tag and child in targets:
                    to_remove.append(child)
            for elem in to_remove:
                parent.remove(elem)
@@ -214,7 +267,7 @@ class RedliningValidator:
        for parent in root.iter():
            to_process = []
            for child in parent:
-                if child.tag == del_tag and child.get(author_attr) == self.author:
+                if child.tag == del_tag and child in targets:
                    to_process.append((child, list(parent).index(child)))

            for del_elem, del_index in reversed(to_process):
@@ -234,8 +287,7 @@ class RedliningValidator:
        for p_elem in root.findall(f".//{p_tag}"):
            text_parts = []
            for t_elem in p_elem.findall(f".//{t_tag}"):
-                if t_elem.text:
-                    text_parts.append(t_elem.text)
+                text_parts.append(self._rendered_text(t_elem))
            paragraph_text = "".join(text_parts)
            if paragraph_text:
                paragraphs.append(paragraph_text)