Rebuild clean MVP document fidelity hardening branch

DECISION_LOG.md

@@ -4,6 +4,37 @@ This file records accepted strategic, product and architecture decisions.
 
 ---
 
+## 2026-07-17 — D030 — Restore existing DOCX header and footer text during deterministic reinsert
+
+Status: accepted implementation decision
+
+Decision:
+
+```text
+Extend the existing local deterministic DOCX reinsert helper to process WordprocessingML text nodes in word/header*.xml and word/footer*.xml in addition to word/document.xml.
+```
+
+Reason:
+
+- The scrubbed DOCX export already replaces reviewed values in body, table, header and footer paragraphs.
+- The Phase 6 matrix showed that reinsert restored body/table values but left header/footer placeholders behind.
+- The gap belongs to document fidelity and reinsert scope, not detection or recognizer behavior.
+
+Boundaries:
+
+- Process only existing body, header and footer WordprocessingML text nodes.
+- Preserve unrelated OOXML package parts byte-for-byte where they are not rewritten.
+- Do not claim support for comments, tracked-change-only parts, footnotes/endnotes, text boxes, metadata or placeholders split across text nodes.
+- Do not add OCR or restored-PDF behavior.
+- Keep processing local, deterministic and Scrub Key driven.
+
+Evidence:
+
+- `output/validation/mvp_phase6_document_hygiene_fidelity_hardening_report.json`
+- `output/validation/mvp_phase6_false_negative_gap_triage.json`
+
+---
+
 ## 2026-07-17 — D029 — Current Phase 6 matrix does not justify a recognizer fix
 
 Status: accepted evidence-routing decision

RELEASE_NOTES.md

@@ -1,3 +1,12 @@
+## 2026-07-17 — DOCX-herstel omvat nu kop- en voetteksten
+
+- Bij het terugzetten van originele waarden in een DOCX worden nu ook bestaande kop- en voetteksten meegenomen.
+- Hoofdtekst en tabellen blijven ondersteund.
+- Opmerkingen, alleen-in-wijzigingen aanwezige tekst, voetnoten/eindnoten, tekstvakken, metadata en placeholders die over meerdere Word-tekstnodes zijn verdeeld, blijven buiten deze versie.
+- PDF-herstel blijft beperkt tot herstelde TXT; OCR en een hersteld PDF-bestand zijn niet toegevoegd.
+
+---
+
 ## 2026-07-16 — Handmatige aanvulling compacter
 
 - `Gemiste waarde toevoegen` gebruikt bij openen een compactere invoerregel voor waarde, type en vervanging.

RISK_REGISTER.md

@@ -73,7 +73,7 @@ Risk:
 DOCX metadata, comments, tracked changes, headers, footers or hidden content contain sensitive data that is not scrubbed or cleaned.
 ```
 
-DOCX hygiene audit remains report-only. Export grouping keeps audit details available and does not imply a clean-DOCX guarantee. The review debug collapse line explicitly keeps audit details available rather than removing them. The Phase 6 synthetic DOCX case now records header/footer findings and the existing main-document-only reinsert boundary as reproducible evidence for the document-hygiene hardening package. Gap triage classifies this as document fidelity and reinsert scope and routes it to `SCRUB-WP_MVP_DOCUMENT_HYGIENE_FIDELITY_HARDENING`.
+DOCX hygiene audit remains report-only. Export grouping keeps audit details available and does not imply a clean-DOCX guarantee. The review debug collapse line explicitly keeps audit details available rather than removing them. The Phase 6 synthetic DOCX case now records header/footer findings and the existing main-document-only reinsert boundary as reproducible evidence for the document-hygiene hardening package. Gap triage classifies this as document fidelity and reinsert scope and routes it to `SCRUB-WP_MVP_DOCUMENT_HYGIENE_FIDELITY_HARDENING`. The hardening package now restores placeholders in existing DOCX header and footer XML parts while retaining hygiene reporting and explicit unsupported-part warnings.
 
 ---
 
@@ -134,7 +134,7 @@ Risk:
 Users may assume PDF support means complete restored PDF reinsert or OCR, while the approved scope is text-based extraction to restored TXT only.
 ```
 
-PDF limitations must remain clear in export/reinsert copy. The Phase 6 text-based PDF case verifies the current restored-TXT-only path and explicitly records that restored PDF and OCR are unsupported. Gap triage retains this as an explicit product boundary and does not authorize OCR or restored-PDF work.
+PDF limitations must remain clear in export/reinsert copy. The Phase 6 text-based PDF case verifies the current restored-TXT-only path and explicitly records that restored PDF and OCR are unsupported. Gap triage retains this as an explicit product boundary and does not authorize OCR or restored-PDF work. Document-fidelity hardening preserves that boundary unchanged.
 
 ---
 

handover/workpackages/20260717_2230_mvp_document_hygiene_fidelity_hardening.md

@@ -0,0 +1,78 @@
+# Handover — SCRUB-WP_MVP_DOCUMENT_HYGIENE_FIDELITY_HARDENING
+
+Repository worked in: solidprivacy-nl/scrub
+
+## Workpackage title
+
+SCRUB-WP_MVP_DOCUMENT_HYGIENE_FIDELITY_HARDENING
+
+## Status
+
+Completed / ready for app verification.
+
+## Files added
+
+- `mvp_document_fidelity_report.py`
+- `scripts/run_mvp_document_hygiene_fidelity_report.py`
+- `tests/test_mvp_document_hygiene_fidelity_hardening.py`
+- `tests/test_mvp_document_fidelity_report.py`
+- `tests/test_mvp_document_fidelity_ui_copy.py`
+- `output/validation/mvp_phase6_document_hygiene_fidelity_hardening_report.json`
+- `handover/workpackages/20260717_2230_mvp_document_hygiene_fidelity_hardening.md`
+
+## Files changed
+
+- `scrub_key_document_reinsert.py`
+- `reinsert_mode_ui.py`
+- `mvp_phase6_document_cases.py`
+- `tests/test_mvp_phase6_e2e_synthetic_validation_matrix.py`
+- `CHANGELOG.md`
+- `WORKPACKAGES.md`
+- `RELEASE_NOTES.md`
+- `DECISION_LOG.md`
+- `RISK_REGISTER.md`
+- `workpackage_claims/scrub_wp_mvp_document_hygiene_fidelity_hardening.md`
+
+## Tests
+
+- Existing TXT/DOCX Scrub Key document-reinsert suite.
+- New body/table/header/footer end-to-end DOCX tests.
+- OOXML package preservation and malformed-header fail-safe tests.
+- Current Phase 6 synthetic matrix tests.
+- Source-level DOCX/PDF capability-copy contract tests.
+- Fidelity report and PDF-boundary tests.
+- Existing DOCX hygiene and document-tool tests.
+- Python compilation and `git diff --check`.
+
+## Validation status
+
+- DOCX header/footer finding resolved: True.
+- Resolved findings: 1.
+- Remaining findings: 1.
+- PDF TXT-only/no-OCR boundary preserved: True.
+- Local-only deterministic processing retained.
+- Human review remains required.
+- Production readiness remains false.
+
+## GitHub Actions status
+
+Pending final PR validation.
+
+## Hugging Face sync status
+
+Pending after merge.
+
+## App verification status
+
+Required after sync because DOCX reinsert behavior changed.
+
+## Remaining risks
+
+- Comments, tracked-change-only parts, footnotes/endnotes, text boxes and metadata remain unsupported by reinsert.
+- Placeholders split across Word text nodes remain unsupported.
+- PDF remains restored TXT only; no OCR or restored PDF output.
+- DOCX hygiene audit remains report-only and does not guarantee a clean document.
+
+## Next recommended step
+
+After app verification, start `SCRUB-WP_MVP_SCRUB_KEY_ROUNDTRIP_VALIDATION`.

mvp_document_fidelity_report.py

@@ -0,0 +1,138 @@
+"""Evidence report for MVP Phase 6 document hygiene and fidelity hardening."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any, Mapping
+
+from mvp_phase6_validation_report import build_validation_report
+
+
+REPORT_SCHEMA = "solidprivacy.mvp_phase6_document_fidelity_hardening_report"
+REPORT_SCHEMA_VERSION = "1.0"
+FIXED_TIMESTAMP = "2026-07-17T20:30:00Z"
+
+
+def build_document_fidelity_report(
+    manifest: Mapping[str, Any],
+    baseline_report: Mapping[str, Any],
+    triage_report: Mapping[str, Any],
+) -> dict[str, Any]:
+    current = build_validation_report(manifest)
+    docx_case = next(
+        item for item in current["cases"]
+        if item["id"] == "docx_mixed_structure_roundtrip"
+    )
+    pdf_case = next(
+        item for item in current["cases"]
+        if item["id"] == "pdf_text_based_to_txt_reinsert"
+    )
+
+    docx_resolved = (
+        docx_case["roundtrip_complete"] is True
+        and docx_case["residual_placeholders"] == []
+        and docx_case["header_footer_roundtrip_values_present"] is True
+        and docx_case["audit_expectations_met"] is True
+        and any(
+            part.startswith("word/header")
+            for part in docx_case["processed_parts"]
+        )
+        and any(
+            part.startswith("word/footer")
+            for part in docx_case["processed_parts"]
+        )
+    )
+    pdf_boundary_preserved = (
+        pdf_case["roundtrip_text_equal"] is True
+        and pdf_case["reinsert_output_type"] == "txt"
+        and pdf_case["restored_pdf_supported"] is False
+        and pdf_case["ocr_supported"] is False
+    )
+
+    baseline_docx_gap = next(
+        item
+        for item in baseline_report["evidence_gaps"]
+        if item["category"] == "known_docx_reinsert_limitation"
+    )
+    triage_docx = next(
+        item
+        for item in triage_report["classifications"]
+        if item["source_category"] == "known_docx_reinsert_limitation"
+    )
+
+    resolved_findings = []
+    if docx_resolved:
+        resolved_findings.append(
+            {
+                "source_case_id": baseline_docx_gap["case_id"],
+                "source_category": baseline_docx_gap["category"],
+                "triage_classification": triage_docx["classification"],
+                "resolution": "DOCX body, tables, headers and footers restore deterministically from the existing Scrub Key.",
+                "resolved_placeholders": docx_case[
+                    "resolved_header_footer_placeholders"
+                ],
+                "processed_parts": docx_case["processed_parts"],
+            }
+        )
+
+    remaining_findings = [
+        {
+            "case_id": pdf_case["id"],
+            "category": "known_pdf_reinsert_limitation",
+            "status": "explicit_product_boundary",
+            "reinsert_output_type": "txt",
+            "restored_pdf_supported": False,
+            "ocr_supported": False,
+        }
+    ]
+
+    return {
+        "schema": REPORT_SCHEMA,
+        "schema_version": REPORT_SCHEMA_VERSION,
+        "generated_at": FIXED_TIMESTAMP,
+        "source_baseline_report": (
+            "output/validation/mvp_phase6_synthetic_validation_report.json"
+        ),
+        "source_triage_report": (
+            "output/validation/mvp_phase6_false_negative_gap_triage.json"
+        ),
+        "synthetic_data_only": True,
+        "human_review_required": True,
+        "production_ready": False,
+        "production_readiness_claim": False,
+        "local_only": True,
+        "ai_processing": False,
+        "cloud_processing": False,
+        "ocr_processing": False,
+        "docx_header_footer_reinsert_resolved": docx_resolved,
+        "pdf_boundary_preserved": pdf_boundary_preserved,
+        "resolved_finding_count": len(resolved_findings),
+        "remaining_finding_count": len(remaining_findings),
+        "resolved_findings": resolved_findings,
+        "remaining_findings": remaining_findings,
+        "current_validation_report": current,
+        "next_recommended_package": (
+            "SCRUB-WP_MVP_SCRUB_KEY_ROUNDTRIP_VALIDATION"
+        ),
+    }
+
+
+def write_document_fidelity_report(
+    manifest: Mapping[str, Any],
+    baseline_report: Mapping[str, Any],
+    triage_report: Mapping[str, Any],
+    output_path: str | Path,
+) -> dict[str, Any]:
+    report = build_document_fidelity_report(
+        manifest,
+        baseline_report,
+        triage_report,
+    )
+    output = Path(output_path)
+    output.parent.mkdir(parents=True, exist_ok=True)
+    output.write_text(
+        json.dumps(report, ensure_ascii=False, indent=2, sort_keys=True) + "\n",
+        encoding="utf-8",
+    )
+    return report

mvp_phase6_document_cases.py

@@ -49,6 +49,21 @@ def build_docx_case(case: Mapping[str, Any]) -> bytes:
     return output.getvalue()
 
 
+def _expected_scope_is_supported(
+    term: str,
+    processed_parts: list[str],
+    limitation_copy: str,
+) -> bool:
+    normalized = str(term).lower()
+    if normalized in limitation_copy:
+        return True
+    if normalized in {"header", "headers"}:
+        return any(part.startswith("word/header") for part in processed_parts)
+    if normalized in {"footer", "footers"}:
+        return any(part.startswith("word/footer") for part in processed_parts)
+    return False
+
+
 def run_docx_case(case: Mapping[str, Any]) -> dict[str, Any]:
     source_docx = build_docx_case(case)
     source_upload = UploadedBytes(f"{case['id']}.docx", source_docx)
@@ -75,18 +90,31 @@ def run_docx_case(case: Mapping[str, Any]) -> dict[str, Any]:
         str(case.get("header_text") or ""),
         str(case.get("footer_text") or ""),
     ]
-    expected_residuals = sorted(
+    formerly_expected_residuals = sorted(
         placeholder
         for original, placeholder in common["replacement_map"].items()
         if any(original in container for container in header_footer_text)
     )
     residuals = detect_placeholders(restored_text)
+    resolved_header_footer_placeholders = sorted(
+        placeholder
+        for placeholder in formerly_expected_residuals
+        if placeholder not in residuals
+    )
     body_values = [
         original
         for original in common["replacement_map"]
         if not any(original in container for container in header_footer_text)
     ]
     body_values_present = all(value in restored_text for value in body_values)
+    header_footer_values = [
+        original
+        for original in common["replacement_map"]
+        if any(original in container for container in header_footer_text)
+    ]
+    header_footer_values_present = all(
+        value in restored_text for value in header_footer_values
+    )
 
     expected_findings = set(case.get("expected_hygiene_findings", []) or [])
     observed_findings = {
@@ -95,19 +123,21 @@ def run_docx_case(case: Mapping[str, Any]) -> dict[str, Any]:
         if finding.get("id")
     }
     audit_met = expected_findings.issubset(observed_findings)
-    residuals_documented = set(expected_residuals).issubset(set(residuals))
+    processed_parts = list(reinsert_result.get("processed_parts", []))
     limitation_copy = " ".join(reinsert_result.get("limitations", [])).lower()
     limitation_met = all(
-        str(term).lower() in limitation_copy
+        _expected_scope_is_supported(term, processed_parts, limitation_copy)
         for term in case.get("expected_reinsert_limitations", []) or []
     )
+    roundtrip_complete = not residuals
 
     status = (
         "pass_with_known_limitations"
         if body_values_present
+        and header_footer_values_present
         and audit_met
-        and residuals_documented
         and limitation_met
+        and roundtrip_complete
         and not common["scrub_key_validation_issues"]
         else "fail"
     )
@@ -127,14 +157,17 @@ def run_docx_case(case: Mapping[str, Any]) -> dict[str, Any]:
         "scrub_key_validation_issues": common["scrub_key_validation_issues"],
         "reinsert_replacement_count": reinsert_result.get("replacement_count"),
         "body_roundtrip_values_present": body_values_present,
-        "expected_residual_placeholders": expected_residuals,
+        "header_footer_roundtrip_values_present": header_footer_values_present,
+        "expected_residual_placeholders": formerly_expected_residuals,
+        "resolved_header_footer_placeholders": resolved_header_footer_placeholders,
         "residual_placeholders": residuals,
+        "processed_parts": processed_parts,
         "hygiene_severity": hygiene_report.get("summary", {}).get("severity"),
         "hygiene_findings": sorted(observed_findings),
         "audit_expectations_met": audit_met,
         "known_limitations": list(reinsert_result.get("limitations", [])),
         "limitation_expectations_met": limitation_met,
-        "roundtrip_complete": not residuals,
+        "roundtrip_complete": roundtrip_complete,
         "local_only": True,
         "ai_processing": False,
         "cloud_processing": False,

output/validation/mvp_document_fidelity_pr_validation.json

@@ -0,0 +1,28 @@
+{
+  "ai_processing": false,
+  "branch": "scrub-mvp-document-hygiene-fidelity-hardening",
+  "cloud_processing": false,
+  "compile_passed": true,
+  "diff_check_passed": true,
+  "generated_at": "2026-07-17T13:13:02.792165+00:00",
+  "head_sha": "4b07e520296f14b7bde2323cad8ce28bbb4d79c5",
+  "human_review_required": true,
+  "main_synchronized": true,
+  "ocr_processing": false,
+  "overall_passed": true,
+  "production_ready": false,
+  "pytest_passed": true,
+  "schema": "solidprivacy.mvp_document_fidelity_pr_validation",
+  "schema_version": "1.0",
+  "synthetic_data_only": true,
+  "tests": [
+    "tests/test_mvp_document_hygiene_fidelity_hardening.py",
+    "tests/test_mvp_document_fidelity_report.py",
+    "tests/test_mvp_document_fidelity_ui_copy.py",
+    "tests/test_mvp_document_fidelity_pr_final_contracts.py",
+    "tests/test_scrub_key_document_reinsert.py",
+    "tests/test_mvp_phase6_e2e_synthetic_validation_matrix.py",
+    "tests/test_mvp_phase6_false_negative_gap_triage.py",
+    "tests/test_docx_hygiene_audit.py"
+  ]
+}

output/validation/mvp_document_fidelity_pr_validation.log

@@ -0,0 +1,8 @@
+main_synchronized=true
+......................................................                   [100%]
+54 passed in 5.56s
+
+compile_status=0
+pytest_status=0
+diff_status=0
+overall_status=0

output/validation/mvp_phase6_document_hygiene_fidelity_hardening_report.json

@@ -0,0 +1,312 @@
+{
+  "ai_processing": false,
+  "cloud_processing": false,
+  "current_validation_report": {
+    "ai_processing": false,
+    "case_count": 3,
+    "cases": [
+      {
+        "ai_processing": false,
+        "cloud_processing": false,
+        "detection": {
+          "ai_processing": false,
+          "analyzer_result_count": 13,
+          "candidate_result_count": 0,
+          "cloud_processing": false,
+          "context_preservation_met": true,
+          "detection_expectations_met": true,
+          "expected_values": [
+            "DOS-2026-778899",
+            "ZK-WOON-55091",
+            "CLNT-2026-0042",
+            "mila.testerveld@example.com",
+            "0612345678",
+            "NL91ABNA0417164300"
+          ],
+          "local_only": true,
+          "missing_expected_values": [],
+          "preserved_terms": [
+            "minderjarige",
+            "arts",
+            "getuige"
+          ],
+          "removed_preserved_terms": [],
+          "rows": [
+            {
+              "end": 235,
+              "entity_type": "NL_PHONE_NUMBER",
+              "score": 1.0,
+              "source": "DutchPhoneRecognizer",
+              "start": 225,
+              "text": "0612345678"
+            },
+            {
+              "end": 168,
+              "entity_type": "NL_POSTCODE",
+              "score": 0.8,
+              "source": "PatternRecognizer",
+              "start": 161,
+              "text": "1234 AB"
+            },
+            {
+              "end": 261,
+              "entity_type": "NL_IBAN",
+              "score": 0.9,
+              "source": "PatternRecognizer",
+              "start": 243,
+              "text": "NL91ABNA0417164300"
+            },
+            {
+              "end": 176,
+              "entity_type": "NL_ADDRESS",
+              "score": 0.66,
+              "source": "PatternRecognizer",
+              "start": 127,
+              "text": "Testerveld woont aan Testlaan 12, 1234 AB Testdam"
+            },
+            {
+              "end": 81,
+              "entity_type": "NL_LEGAL_CASE_NUMBER",
+              "score": 0.86,
+              "source": "NL_LEGAL_CASE_NUMBER_capture_recognizer",
+              "start": 68,
+              "text": "ZK-WOON-55091"
+            },
+            {
+              "end": 55,
+              "entity_type": "NL_DOSSIER_NUMBER",
+              "score": 0.83,
+              "source": "NL_DOSSIER_NUMBER_capture_recognizer",
+              "start": 40,
+              "text": "DOS-2026-778899"
+            },
+            {
+              "end": 105,
+              "entity_type": "NL_CLIENT_NUMBER",
+              "score": 0.86,
+              "source": "NL_CLIENT_NUMBER_capture_recognizer",
+              "start": 96,
+              "text": "CLNT-2026"
+            },
+            {
+              "end": 137,
+              "entity_type": "NL_LEGAL_PARTY_NAME",
+              "score": 0.79,
+              "source": "NL_LEGAL_PARTY_NAME_capture_recognizer",
+              "start": 122,
+              "text": "Mila Testerveld"
+            },
+            {
+              "end": 24,
+              "entity_type": "NL_COURT_OR_AUTHORITY",
+              "score": 0.7,
+              "source": "PatternRecognizer",
+              "start": 7,
+              "text": "Rechtbank Testdam"
+            },
+            {
+              "end": 110,
+              "entity_type": "NL_CLIENT_REFERENCE",
+              "score": 0.9,
+              "source": "DutchContextualReferenceRecognizer",
+              "start": 96,
+              "text": "CLNT-2026-0042"
+            },
+            {
+              "end": 213,
+              "entity_type": "EMAIL_ADDRESS",
+              "score": 1.0,
+              "source": "EmailRecognizer",
+              "start": 186,
+              "text": "mila.testerveld@example.com"
+            }
+          ]
+        },
+        "document_type": "txt",
+        "export_import_types": [
+          "docx",
+          "pdf"
+        ],
+        "export_placeholders_visible": true,
+        "id": "txt_legal_core_roundtrip",
+        "known_limitations": [],
+        "local_only": true,
+        "manual_additions": [
+          {
+            "is_valid": true,
+            "manual_type": "Persoon",
+            "message": "",
+            "placeholder": "[PERSOON_HANDMATIG_01]",
+            "value": "Mila Testerveld"
+          },
+          {
+            "is_valid": true,
+            "manual_type": "Anders",
+            "message": "",
+            "placeholder": "[WAARDE_HANDMATIG_01]",
+            "value": "lantaarnbloem"
+          }
+        ],
+        "reinsert_replacement_count": 8,
+        "review_row_count": 8,
+        "roundtrip_exact": true,
+        "scrub_key_item_count": 8,
+        "scrub_key_validation_issues": [],
+        "scrub_report_requires_manual_review": true,
+        "scrubbed_text": "Aan de Rechtbank Testdam.\nDossiernummer [DOSSIERNUMMER_01].\nZaaknummer [ZAAKREFERENTIE_01].\nClientnummer [CLIENTNUMMER_01].\nVerzoeker [PERSOON_HANDMATIG_01] woont aan Testlaan 12, 1234 AB Testdam.\nE-mail: [EMAIL_01].\nTelefoon: [TELEFOON_01].\nIBAN: [IBAN_01].\nDe minderjarige sprak met de arts en de getuige.\nInterne testwaarde [WAARDE_HANDMATIG_01] bleef onopgemerkt.",
+        "source_import_type": "txt",
+        "status": "pass"
+      },
+      {
+        "ai_processing": false,
+        "audit_expectations_met": true,
+        "body_roundtrip_values_present": true,
+        "cloud_processing": false,
+        "document_type": "docx",
+        "expected_residual_placeholders": [
+          "[CLIENT_REFERENTIE_01]",
+          "[OVERIGE_REFERENTIE_01]"
+        ],
+        "header_footer_roundtrip_values_present": true,
+        "hygiene_findings": [
+          "footers_detected",
+          "headers_detected"
+        ],
+        "hygiene_severity": "high",
+        "id": "docx_mixed_structure_roundtrip",
+        "known_limitations": [
+          "DOCX helper processes word/document.xml plus word/header*.xml and word/footer*.xml text nodes.",
+          "Normal body paragraphs, body tables and header/footer text are supported.",
+          "Headers and footers are processed together with the main document body.",
+          "Placeholders split across multiple Word runs/text nodes are not restored in this version.",
+          "Comments, tracked-change-only parts, footnotes/endnotes, text boxes and metadata are not processed in this version."
+        ],
+        "limitation_expectations_met": true,
+        "local_only": true,
+        "processed_parts": [
+          "word/document.xml",
+          "word/header1.xml",
+          "word/header2.xml",
+          "word/header3.xml",
+          "word/footer1.xml",
+          "word/footer2.xml",
+          "word/footer3.xml"
+        ],
+        "reinsert_replacement_count": 6,
+        "residual_placeholders": [],
+        "resolved_header_footer_placeholders": [
+          "[CLIENT_REFERENTIE_01]",
+          "[OVERIGE_REFERENTIE_01]"
+        ],
+        "restored_import_type": "docx",
+        "restored_text": "Verzoeker Mila Testerveld behandelt zaak ZK-WOON-55091.\nDe minderjarige blijft als juridische rol leesbaar.\nDossier DOS-2026-778899\nClient CLNT-2026-0042\nVERTROUWELIJK CL-FAM-55201\nPagina TEST-FOOTER-001",
+        "review_row_count": 6,
+        "roundtrip_complete": true,
+        "scrub_key_item_count": 6,
+        "scrub_key_validation_issues": [],
+        "scrubbed_import_type": "docx",
+        "scrubbed_text": "Verzoeker [PERSOON_01] behandelt zaak [ZAAKREFERENTIE_01].\nDe minderjarige blijft als juridische rol leesbaar.\nDossier [DOSSIERNUMMER_01]\nClient [CLIENTNUMMER_01]\nVERTROUWELIJK [CLIENT_REFERENTIE_01]\nPagina [OVERIGE_REFERENTIE_01]",
+        "source_import_type": "docx",
+        "source_text": "Verzoeker Mila Testerveld behandelt zaak ZK-WOON-55091.\nDe minderjarige blijft als juridische rol leesbaar.\nDossier DOS-2026-778899\nClient CLNT-2026-0042\nVERTROUWELIJK CL-FAM-55201\nPagina TEST-FOOTER-001",
+        "status": "pass_with_known_limitations"
+      },
+      {
+        "ai_processing": false,
+        "cloud_processing": false,
+        "document_type": "pdf",
+        "id": "pdf_text_based_to_txt_reinsert",
+        "known_limitations": [
+          "PDF reinsert produces restored TXT only.",
+          "No restored PDF output is supported.",
+          "OCR and scanned/image-only PDFs are unsupported."
+        ],
+        "limitation_contract_met": true,
+        "local_only": true,
+        "ocr_supported": false,
+        "reinsert_output_type": "txt",
+        "reinsert_replacement_count": 3,
+        "restored_pdf_supported": false,
+        "restored_text": "Zaak ZK-WOON-55091 betreft Mila Testerveld. Dossier DOS-2026-778899.",
+        "review_row_count": 3,
+        "roundtrip_text_equal": true,
+        "scrub_key_item_count": 3,
+        "scrub_key_validation_issues": [],
+        "scrubbed_import_type": "pdf",
+        "scrubbed_text": "Zaak [ZAAKREFERENTIE_01] betreft [PERSOON_01]. Dossier [DOSSIERNUMMER_01].",
+        "source_import_type": "pdf",
+        "source_text": "Zaak ZK-WOON-55091 betreft Mila Testerveld. Dossier DOS-2026-778899.",
+        "status": "pass_with_known_limitations"
+      }
+    ],
+    "cloud_processing": false,
+    "evidence_gap_count": 1,
+    "evidence_gaps": [
+      {
+        "case_id": "pdf_text_based_to_txt_reinsert",
+        "category": "known_pdf_reinsert_limitation",
+        "value": "restored TXT only; no OCR or restored PDF"
+      }
+    ],
+    "failing_case_count": 0,
+    "failing_cases": [],
+    "generated_at": "2026-07-17T18:20:00Z",
+    "human_review_required": true,
+    "local_only": true,
+    "manifest_schema": "solidprivacy.mvp_phase6_validation_matrix",
+    "manifest_schema_version": "1.0",
+    "next_recommended_package": "SCRUB-WP_MVP_FALSE_NEGATIVE_GAP_TRIAGE",
+    "ocr_processing": false,
+    "production_readiness_claim": false,
+    "production_ready": false,
+    "schema": "solidprivacy.mvp_phase6_validation_report",
+    "schema_version": "1.0",
+    "synthetic_data_only": true
+  },
+  "docx_header_footer_reinsert_resolved": true,
+  "generated_at": "2026-07-17T20:30:00Z",
+  "human_review_required": true,
+  "local_only": true,
+  "next_recommended_package": "SCRUB-WP_MVP_SCRUB_KEY_ROUNDTRIP_VALIDATION",
+  "ocr_processing": false,
+  "pdf_boundary_preserved": true,
+  "production_readiness_claim": false,
+  "production_ready": false,
+  "remaining_finding_count": 1,
+  "remaining_findings": [
+    {
+      "case_id": "pdf_text_based_to_txt_reinsert",
+      "category": "known_pdf_reinsert_limitation",
+      "ocr_supported": false,
+      "reinsert_output_type": "txt",
+      "restored_pdf_supported": false,
+      "status": "explicit_product_boundary"
+    }
+  ],
+  "resolved_finding_count": 1,
+  "resolved_findings": [
+    {
+      "processed_parts": [
+        "word/document.xml",
+        "word/header1.xml",
+        "word/header2.xml",
+        "word/header3.xml",
+        "word/footer1.xml",
+        "word/footer2.xml",
+        "word/footer3.xml"
+      ],
+      "resolution": "DOCX body, tables, headers and footers restore deterministically from the existing Scrub Key.",
+      "resolved_placeholders": [
+        "[CLIENT_REFERENTIE_01]",
+        "[OVERIGE_REFERENTIE_01]"
+      ],
+      "source_case_id": "docx_mixed_structure_roundtrip",
+      "source_category": "known_docx_reinsert_limitation",
+      "triage_classification": "document_fidelity_and_reinsert_scope"
+    }
+  ],
+  "schema": "solidprivacy.mvp_phase6_document_fidelity_hardening_report",
+  "schema_version": "1.0",
+  "source_baseline_report": "output/validation/mvp_phase6_synthetic_validation_report.json",
+  "source_triage_report": "output/validation/mvp_phase6_false_negative_gap_triage.json",
+  "synthetic_data_only": true
+}

reinsert_mode_ui.py

@@ -209,9 +209,9 @@ def render_reinsert_mode() -> None:
         st.warning(CONFIDENTIAL_OUTPUT_WARNING)
         st.caption("Upload een DOCX-bestand met placeholders. Er wordt geen AI- of cloudverwerking gebruikt.")
         st.info(
-            "Let op: DOCX-terugzetten ondersteunt in deze versie normale documenttekst en tabellen. "
-            "Headers, footers, opmerkingen, bijgehouden wijzigingen en placeholders die door Word "
-            "over meerdere tekstfragmenten zijn gesplitst worden nog niet volledig ondersteund."
+            "DOCX-terugzetten ondersteunt normale documenttekst, tabellen en bestaande kop- en voetteksten. "
+            "Opmerkingen, bijgehouden wijzigingen, voetnoten/eindnoten, tekstvakken, metadata en placeholders "
+            "die door Word over meerdere tekstfragmenten zijn gesplitst worden nog niet volledig ondersteund."
         )
         docx_reinsert_file = st.file_uploader(
             "Upload een DOCX-bestand met placeholders",

scripts/run_mvp_document_hygiene_fidelity_report.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from mvp_document_fidelity_report import write_document_fidelity_report
+from mvp_phase6_validation_manifest import load_validation_manifest
+
+
+MANIFEST = Path("test_cases/mvp_phase6/validation_manifest.json")
+BASELINE = Path("output/validation/mvp_phase6_synthetic_validation_report.json")
+TRIAGE = Path("output/validation/mvp_phase6_false_negative_gap_triage.json")
+OUTPUT = Path(
+    "output/validation/mvp_phase6_document_hygiene_fidelity_hardening_report.json"
+)
+
+
+def _json(path: Path) -> dict:
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def main() -> None:
+    report = write_document_fidelity_report(
+        load_validation_manifest(MANIFEST),
+        _json(BASELINE),
+        _json(TRIAGE),
+        OUTPUT,
+    )
+    print(
+        f"Wrote {OUTPUT}: resolved={report['resolved_finding_count']}, "
+        f"remaining={report['remaining_finding_count']}."
+    )
+
+
+if __name__ == "__main__":
+    main()

scrub_key_document_reinsert.py

@@ -5,11 +5,15 @@ for TXT and DOCX inputs. They deliberately avoid Streamlit UI integration,
 PDF handling, AI calls, remote processing, file-system persistence and export
 semantic changes.
 
-DOCX support is intentionally limited in this foundation version:
-- only `word/document.xml` text nodes are processed;
-- normal body paragraphs and tables in `word/document.xml` are covered;
-- placeholders split across multiple Word runs/text nodes are not restored;
-- headers, footers, comments, tracked changes and metadata are not processed.
+DOCX support covers text nodes in:
+- ``word/document.xml``;
+- ``word/header*.xml``;
+- ``word/footer*.xml``.
+
+Normal body paragraphs, body tables and header/footer text are restored. The
+helper still does not restore placeholders split across multiple Word text
+nodes, comments, tracked-change-only parts, footnotes/endnotes, text boxes or
+metadata.
 """
 
 from __future__ import annotations
@@ -17,19 +21,23 @@ from __future__ import annotations
 from io import BytesIO
 from typing import Any
 from zipfile import ZIP_DEFLATED, BadZipFile, ZipFile
+import re
 import xml.etree.ElementTree as ET
 
 from scrub_key_reinsert import reinsert_from_scrub_key
 
 DOCX_MAIN_DOCUMENT = "word/document.xml"
+DOCX_HEADER_RE = re.compile(r"^word/header[^/]*\.xml$")
+DOCX_FOOTER_RE = re.compile(r"^word/footer[^/]*\.xml$")
 WORDPROCESSINGML_NS = "http://schemas.openxmlformats.org/wordprocessingml/2006/main"
 XML_NS = "http://www.w3.org/XML/1998/namespace"
 
 DOCX_LIMITATIONS = [
-    "DOCX helper processes only word/document.xml text nodes in this foundation version.",
-    "Normal body paragraphs and tables in word/document.xml are supported.",
+    "DOCX helper processes word/document.xml plus word/header*.xml and word/footer*.xml text nodes.",
+    "Normal body paragraphs, body tables and header/footer text are supported.",
+    "Headers and footers are processed together with the main document body.",
     "Placeholders split across multiple Word runs/text nodes are not restored in this version.",
-    "Headers, footers, comments, tracked changes and metadata are not processed in this version.",
+    "Comments, tracked-change-only parts, footnotes/endnotes, text boxes and metadata are not processed in this version.",
 ]
 
 ET.register_namespace("w", WORDPROCESSINGML_NS)
@@ -48,11 +56,7 @@ def _with_document_metadata(result: dict[str, Any], document_type: str) -> dict[
 
 
 def reinsert_text_document(text: str, scrub_key: dict[str, Any]) -> dict[str, Any]:
-    """Reinsert placeholders in plain text and return restored text plus audit.
-
-    This is a document-level wrapper around ``reinsert_from_scrub_key`` for plain
-    text/TXT use cases. It does not mutate the supplied Scrub Key.
-    """
+    """Reinsert placeholders in plain text and return restored text plus audit."""
     result = _with_document_metadata(reinsert_from_scrub_key(text, scrub_key), "txt")
     result["content"] = result.get("text", "")
     result["limitations"] = []
@@ -64,11 +68,7 @@ def reinsert_txt_bytes(
     scrub_key: dict[str, Any],
     encoding: str = "utf-8",
 ) -> dict[str, Any]:
-    """Decode TXT bytes, reinsert placeholders and return restored text/bytes.
-
-    Decoding is strict by default so invalid input is reported instead of being
-    silently changed. No file-system writes are performed.
-    """
+    """Decode TXT bytes, reinsert placeholders and return restored text/bytes."""
     if not isinstance(content, (bytes, bytearray)):
         result = reinsert_text_document("", scrub_key)
         result["validation_issues"] = ["TXT content must be bytes."]
@@ -111,6 +111,9 @@ def _docx_validation_result(content: bytes, message: str) -> dict[str, Any]:
         "cloud_processing": False,
         "limitations": list(DOCX_LIMITATIONS),
         "unsupported_parts": list(DOCX_LIMITATIONS),
+        "processed_parts": [],
+        "processed_part_count": 0,
+        "part_texts": {},
     }
 
 
@@ -118,23 +121,50 @@ def _word_text_nodes(root: ET.Element) -> list[ET.Element]:
     return list(root.iter(f"{{{WORDPROCESSINGML_NS}}}t"))
 
 
-def _serialize_package_with_document_xml(content: bytes, document_xml: bytes) -> bytes:
+def _supported_docx_xml_parts(names: set[str]) -> list[str]:
+    parts = [DOCX_MAIN_DOCUMENT]
+    parts.extend(sorted(name for name in names if DOCX_HEADER_RE.match(name)))
+    parts.extend(sorted(name for name in names if DOCX_FOOTER_RE.match(name)))
+    return parts
+
+
+def _serialize_package_with_xml_parts(
+    content: bytes,
+    replacement_parts: dict[str, bytes],
+) -> bytes:
     output = BytesIO()
-    with ZipFile(BytesIO(content), "r") as source_package, ZipFile(output, "w", ZIP_DEFLATED) as target_package:
+    with ZipFile(BytesIO(content), "r") as source_package, ZipFile(
+        output,
+        "w",
+        ZIP_DEFLATED,
+    ) as target_package:
         for entry in source_package.infolist():
-            data = document_xml if entry.filename == DOCX_MAIN_DOCUMENT else source_package.read(entry.filename)
+            data = replacement_parts.get(entry.filename)
+            if data is None:
+                data = source_package.read(entry.filename)
             target_package.writestr(entry, data)
     return output.getvalue()
 
 
+def _parse_supported_parts(
+    package: ZipFile,
+    part_names: list[str],
+) -> tuple[dict[str, ET.Element], str | None]:
+    roots: dict[str, ET.Element] = {}
+    for part_name in part_names:
+        try:
+            roots[part_name] = ET.fromstring(package.read(part_name))
+        except ET.ParseError as exc:
+            return {}, f"DOCX {part_name} could not be parsed: {exc}"
+    return roots, None
+
+
 def reinsert_docx_bytes(content: bytes, scrub_key: dict[str, Any]) -> dict[str, Any]:
-    """Reinsert placeholders in the main body of a DOCX document.
+    """Reinsert placeholders in supported DOCX body/header/footer text nodes.
 
-    This foundation helper processes ``word/document.xml`` text nodes only. That
-    covers normal paragraphs and tables in the main document body, while leaving
-    headers, footers, comments, tracked changes and metadata untouched. It returns
-    restored DOCX bytes and an audit summary. The input bytes and Scrub Key are
-    not mutated.
+    The input bytes and Scrub Key are not mutated. All supported OOXML parts are
+    validated before any output package is produced. Audit counts and unresolved
+    placeholders cover the combined supported text surface.
     """
     if not isinstance(content, (bytes, bytearray)):
         return _docx_validation_result(b"", "DOCX content must be bytes.")
@@ -149,30 +179,67 @@ def reinsert_docx_bytes(content: bytes, scrub_key: dict[str, Any]) -> dict[str,
                     original_content,
                     "DOCX package is missing word/document.xml.",
                 )
-            document_xml = docx_package.read(DOCX_MAIN_DOCUMENT)
+            part_names = _supported_docx_xml_parts(names)
+            roots, parse_issue = _parse_supported_parts(docx_package, part_names)
     except BadZipFile:
-        return _docx_validation_result(original_content, "DOCX content is not a valid OOXML package.")
+        return _docx_validation_result(
+            original_content,
+            "DOCX content is not a valid OOXML package.",
+        )
 
-    try:
-        root = ET.fromstring(document_xml)
-    except ET.ParseError as exc:
-        return _docx_validation_result(original_content, f"DOCX document.xml could not be parsed: {exc}")
+    if parse_issue:
+        return _docx_validation_result(original_content, parse_issue)
 
-    text_nodes = _word_text_nodes(root)
-    original_text = "\n".join(node.text or "" for node in text_nodes)
-    audit_result = _with_document_metadata(reinsert_from_scrub_key(original_text, scrub_key), "docx")
+    part_nodes = {
+        part_name: _word_text_nodes(root)
+        for part_name, root in roots.items()
+    }
+    original_part_texts = {
+        part_name: "\n".join(node.text or "" for node in nodes)
+        for part_name, nodes in part_nodes.items()
+    }
+    combined_original_text = "\n".join(
+        original_part_texts[part_name]
+        for part_name in part_names
+    )
+    audit_result = _with_document_metadata(
+        reinsert_from_scrub_key(combined_original_text, scrub_key),
+        "docx",
+    )
 
     if not audit_result.get("validation_issues"):
-        for node in text_nodes:
-            node_result = reinsert_from_scrub_key(node.text or "", scrub_key)
-            node.text = node_result.get("text", "")
-
-    restored_document_xml = ET.tostring(root, encoding="utf-8", xml_declaration=True)
-    restored_docx = _serialize_package_with_document_xml(original_content, restored_document_xml)
-
-    audit_result["text"] = "\n".join(node.text or "" for node in text_nodes)
-    audit_result["content"] = audit_result["text"]
+        for nodes in part_nodes.values():
+            for node in nodes:
+                node_result = reinsert_from_scrub_key(node.text or "", scrub_key)
+                node.text = node_result.get("text", "")
+
+    restored_part_texts = {
+        part_name: "\n".join(node.text or "" for node in part_nodes[part_name])
+        for part_name in part_names
+    }
+    restored_xml_parts = {
+        part_name: ET.tostring(
+            roots[part_name],
+            encoding="utf-8",
+            xml_declaration=True,
+        )
+        for part_name in part_names
+    }
+    restored_docx = _serialize_package_with_xml_parts(
+        original_content,
+        restored_xml_parts,
+    )
+    combined_restored_text = "\n".join(
+        restored_part_texts[part_name]
+        for part_name in part_names
+    )
+
+    audit_result["text"] = combined_restored_text
+    audit_result["content"] = combined_restored_text
     audit_result["docx_bytes"] = restored_docx
     audit_result["limitations"] = list(DOCX_LIMITATIONS)
     audit_result["unsupported_parts"] = list(DOCX_LIMITATIONS)
+    audit_result["processed_parts"] = list(part_names)
+    audit_result["processed_part_count"] = len(part_names)
+    audit_result["part_texts"] = restored_part_texts
     return audit_result

tests/test_mvp_document_fidelity_pr_final_contracts.py

@@ -0,0 +1,42 @@
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def test_temporary_document_fidelity_patch_scripts_are_absent() -> None:
+    assert not (ROOT / "scripts" / "patch_docx_reinsert_capability_copy_only.py").exists()
+    assert not (ROOT / "scripts" / "finalize_mvp_document_fidelity_pr_cleanup.py").exists()
+
+
+def test_document_fidelity_governance_evidence_has_no_duplicate_lines() -> None:
+    changelog = (ROOT / "CHANGELOG.md").read_text(encoding="utf-8")
+    workpackages = (ROOT / "WORKPACKAGES.md").read_text(encoding="utf-8")
+    handover = (
+        ROOT
+        / "handover"
+        / "workpackages"
+        / "20260717_2230_mvp_document_hygiene_fidelity_hardening.md"
+    ).read_text(encoding="utf-8")
+
+    assert changelog.count("- `tests/test_mvp_document_fidelity_ui_copy.py`") == 1
+    assert changelog.count(
+        "The DOCX reinsert capability copy now matches the supported body/table/header/footer scope."
+    ) == 1
+    assert workpackages.count(
+        "Aligned the existing DOCX reinsert information copy with the supported body/table/header/footer scope without adding controls."
+    ) == 1
+    assert handover.count("- `tests/test_mvp_document_fidelity_ui_copy.py`") == 1
+    assert handover.count("Source-level DOCX/PDF capability-copy contract tests.") == 1
+
+
+def test_final_claim_preserves_verification_and_product_boundaries() -> None:
+    claim = (
+        ROOT
+        / "workpackage_claims"
+        / "scrub_wp_mvp_document_hygiene_fidelity_hardening.md"
+    ).read_text(encoding="utf-8")
+
+    assert "DOCX header/footer reinsert resolved: true" in claim
+    assert "No OCR or restored-PDF implementation" in claim
+    assert "App verification required after Actions and Hugging Face sync" in claim

tests/test_mvp_document_fidelity_report.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from mvp_document_fidelity_report import (
+    build_document_fidelity_report,
+    write_document_fidelity_report,
+)
+from mvp_phase6_validation_manifest import load_validation_manifest
+
+
+ROOT = Path(__file__).resolve().parents[1]
+MANIFEST = ROOT / "test_cases" / "mvp_phase6" / "validation_manifest.json"
+BASELINE = ROOT / "output" / "validation" / "mvp_phase6_synthetic_validation_report.json"
+TRIAGE = ROOT / "output" / "validation" / "mvp_phase6_false_negative_gap_triage.json"
+
+
+def _json(path: Path) -> dict:
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def _report() -> dict:
+    return build_document_fidelity_report(
+        load_validation_manifest(MANIFEST),
+        _json(BASELINE),
+        _json(TRIAGE),
+    )
+
+
+def test_hardening_report_closes_docx_header_footer_finding() -> None:
+    report = _report()
+
+    assert report["schema"] == (
+        "solidprivacy.mvp_phase6_document_fidelity_hardening_report"
+    )
+    assert report["schema_version"] == "1.0"
+    assert report["docx_header_footer_reinsert_resolved"] is True
+    assert report["resolved_finding_count"] == 1
+    assert report["remaining_finding_count"] == 1
+
+    resolved = report["resolved_findings"][0]
+    assert resolved["source_category"] == "known_docx_reinsert_limitation"
+    assert set(resolved["resolved_placeholders"]) == {
+        "[CLIENT_REFERENTIE_01]",
+        "[OVERIGE_REFERENTIE_01]",
+    }
+    assert any(part.startswith("word/header") for part in resolved["processed_parts"])
+    assert any(part.startswith("word/footer") for part in resolved["processed_parts"])
+
+
+def test_pdf_boundary_remains_explicit_and_unexpanded() -> None:
+    report = _report()
+
+    assert report["pdf_boundary_preserved"] is True
+    remaining = report["remaining_findings"][0]
+    assert remaining["category"] == "known_pdf_reinsert_limitation"
+    assert remaining["status"] == "explicit_product_boundary"
+    assert remaining["reinsert_output_type"] == "txt"
+    assert remaining["restored_pdf_supported"] is False
+    assert remaining["ocr_supported"] is False
+
+
+def test_current_matrix_has_no_docx_residual_gap() -> None:
+    current = _report()["current_validation_report"]
+    docx = next(case for case in current["cases"] if case["document_type"] == "docx")
+
+    assert current["failing_case_count"] == 0
+    assert docx["roundtrip_complete"] is True
+    assert docx["residual_placeholders"] == []
+    assert docx["header_footer_roundtrip_values_present"] is True
+    assert {gap["category"] for gap in current["evidence_gaps"]} == {
+        "known_pdf_reinsert_limitation"
+    }
+
+
+def test_report_retains_privacy_and_claim_boundaries() -> None:
+    report = _report()
+
+    assert report["synthetic_data_only"] is True
+    assert report["human_review_required"] is True
+    assert report["production_ready"] is False
+    assert report["production_readiness_claim"] is False
+    assert report["local_only"] is True
+    assert report["ai_processing"] is False
+    assert report["cloud_processing"] is False
+    assert report["ocr_processing"] is False
+    assert report["next_recommended_package"] == (
+        "SCRUB-WP_MVP_SCRUB_KEY_ROUNDTRIP_VALIDATION"
+    )
+
+
+def test_report_writer_is_deterministic(tmp_path: Path) -> None:
+    output = tmp_path / "hardening.json"
+    first = write_document_fidelity_report(
+        load_validation_manifest(MANIFEST),
+        _json(BASELINE),
+        _json(TRIAGE),
+        output,
+    )
+    first_text = output.read_text(encoding="utf-8")
+    second = write_document_fidelity_report(
+        load_validation_manifest(MANIFEST),
+        _json(BASELINE),
+        _json(TRIAGE),
+        output,
+    )
+
+    assert first == second
+    assert first_text == output.read_text(encoding="utf-8")
+    assert json.loads(first_text) == first

tests/test_mvp_document_fidelity_ui_copy.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[1]
+UI = ROOT / "reinsert_mode_ui.py"
+THIS_TEST = ROOT / "tests" / "test_mvp_document_fidelity_ui_copy.py"
+
+
+def test_docx_reinsert_copy_matches_supported_parts() -> None:
+    text = UI.read_text(encoding="utf-8")
+
+    assert "normale documenttekst, tabellen en bestaande kop- en voetteksten" in text
+    assert "Opmerkingen, bijgehouden wijzigingen, voetnoten/eindnoten, tekstvakken, metadata" in text
+    assert "over meerdere tekstfragmenten zijn gesplitst" in text
+    assert "Headers, footers" not in text
+
+
+def test_pdf_txt_only_and_no_ocr_copy_remains_unchanged() -> None:
+    text = UI.read_text(encoding="utf-8")
+
+    assert "Deze functie maakt geen herstelde PDF" in text
+    assert "OCR niet beschikbaar" in text
+    assert "PDF-output: Nee" in text
+
+
+def test_copy_contract_does_not_import_streamlit_or_product_ui() -> None:
+    tree = ast.parse(THIS_TEST.read_text(encoding="utf-8"))
+    imported_roots: set[str] = set()
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            imported_roots.update(alias.name.split(".")[0] for alias in node.names)
+        elif isinstance(node, ast.ImportFrom) and node.module:
+            imported_roots.add(node.module.split(".")[0])
+
+    assert "streamlit" not in imported_roots
+    assert "reinsert_mode_ui" not in imported_roots

tests/test_mvp_document_hygiene_fidelity_hardening.py

@@ -0,0 +1,203 @@
+from __future__ import annotations
+
+from io import BytesIO
+from pathlib import Path
+from zipfile import ZIP_DEFLATED, ZipFile
+
+from docx import Document
+
+from document_tools import anonymized_docx_from_original
+from scrub_key import build_scrub_key
+from scrub_key_document_reinsert import (
+    DOCX_LIMITATIONS,
+    reinsert_docx_bytes,
+)
+
+
+class UploadedBytes:
+    def __init__(self, name: str, content: bytes):
+        self.name = name
+        self._content = bytes(content)
+
+    def getvalue(self) -> bytes:
+        return self._content
+
+
+ROWS = [
+    {
+        "original_value": "BETROKKENE-TEST-A",
+        "placeholder": "[PERSOON_1]",
+        "entity_type": "PERSON",
+        "type_label": "Naam",
+        "source": "detected",
+        "review_status": "auto_detected",
+        "include": True,
+        "timestamp": "2026-07-17T20:30:00Z",
+    },
+    {
+        "original_value": "RECHTBANK TESTDAM",
+        "placeholder": "[ORGANISATIE_01]",
+        "entity_type": "ORGANIZATION",
+        "type_label": "Organisatie",
+        "source": "detected",
+        "review_status": "auto_detected",
+        "include": True,
+        "timestamp": "2026-07-17T20:30:01Z",
+    },
+    {
+        "original_value": "ZAAK-TEST-2026-001",
+        "placeholder": "[ZAAKNUMMER_1]",
+        "entity_type": "LEGAL_REFERENCE",
+        "type_label": "Zaaknummer",
+        "source": "manual",
+        "review_status": "manual",
+        "include": True,
+        "timestamp": "2026-07-17T20:30:02Z",
+    },
+]
+
+REPLACEMENTS = {
+    row["original_value"]: row["placeholder"]
+    for row in ROWS
+}
+
+
+def _scrub_key() -> dict:
+    return build_scrub_key(ROWS, document_label="Synthetisch fidelitydossier")
+
+
+def _source_docx() -> bytes:
+    document = Document()
+    document.add_paragraph("Body BETROKKENE-TEST-A")
+    table = document.add_table(rows=1, cols=1)
+    table.cell(0, 0).text = "Tabel ZAAK-TEST-2026-001"
+    section = document.sections[0]
+    section.header.paragraphs[0].text = "Header RECHTBANK TESTDAM"
+    section.footer.paragraphs[0].text = "Footer ZAAK-TEST-2026-001"
+    output = BytesIO()
+    document.save(output)
+    return output.getvalue()
+
+
+def _text_surfaces(docx_bytes: bytes) -> dict[str, str]:
+    document = Document(BytesIO(docx_bytes))
+    section = document.sections[0]
+    return {
+        "body": "\n".join(paragraph.text for paragraph in document.paragraphs),
+        "table": "\n".join(
+            paragraph.text
+            for table in document.tables
+            for row in table.rows
+            for cell in row.cells
+            for paragraph in cell.paragraphs
+        ),
+        "header": "\n".join(paragraph.text for paragraph in section.header.paragraphs),
+        "footer": "\n".join(paragraph.text for paragraph in section.footer.paragraphs),
+    }
+
+
+def test_scrub_then_reinsert_restores_body_table_header_and_footer() -> None:
+    source = _source_docx()
+    scrubbed = anonymized_docx_from_original(
+        UploadedBytes("synthetic.docx", source),
+        REPLACEMENTS,
+    )
+    scrubbed_surfaces = _text_surfaces(scrubbed)
+
+    assert "[PERSOON_1]" in scrubbed_surfaces["body"]
+    assert "[ZAAKNUMMER_1]" in scrubbed_surfaces["table"]
+    assert "[ORGANISATIE_01]" in scrubbed_surfaces["header"]
+    assert "[ZAAKNUMMER_1]" in scrubbed_surfaces["footer"]
+
+    result = reinsert_docx_bytes(scrubbed, _scrub_key())
+    restored = _text_surfaces(result["docx_bytes"])
+
+    assert restored["body"] == "Body BETROKKENE-TEST-A"
+    assert restored["table"] == "Tabel ZAAK-TEST-2026-001"
+    assert restored["header"] == "Header RECHTBANK TESTDAM"
+    assert restored["footer"] == "Footer ZAAK-TEST-2026-001"
+    assert result["replacement_count"] == 4
+    assert result["placeholders_not_found"] == []
+    assert result["unknown_placeholders"] == []
+    assert result["validation_issues"] == []
+
+
+def test_result_reports_processed_ooxml_parts() -> None:
+    scrubbed = anonymized_docx_from_original(
+        UploadedBytes("synthetic.docx", _source_docx()),
+        REPLACEMENTS,
+    )
+    result = reinsert_docx_bytes(scrubbed, _scrub_key())
+
+    assert "word/document.xml" in result["processed_parts"]
+    assert any(part.startswith("word/header") for part in result["processed_parts"])
+    assert any(part.startswith("word/footer") for part in result["processed_parts"])
+    assert result["processed_part_count"] == len(result["processed_parts"])
+    assert set(result["processed_parts"]) == set(result["part_texts"])
+    assert result["local_only"] is True
+    assert result["ai_processing"] is False
+    assert result["cloud_processing"] is False
+
+
+def test_comments_tracked_changes_metadata_and_split_nodes_remain_unsupported() -> None:
+    limitation_text = " ".join(DOCX_LIMITATIONS).lower()
+
+    assert "header/footer text are supported" in limitation_text
+    assert "split" in limitation_text
+    assert "comments" in limitation_text
+    assert "tracked" in limitation_text
+    assert "metadata" in limitation_text
+    assert "not processed" in limitation_text
+
+
+def test_unrelated_package_parts_are_preserved_byte_for_byte() -> None:
+    marker_path = "customXml/synthetic-marker.xml"
+    marker_bytes = b"<synthetic>KEEP-ME</synthetic>"
+    scrubbed = anonymized_docx_from_original(
+        UploadedBytes("synthetic.docx", _source_docx()),
+        REPLACEMENTS,
+    )
+    enriched = BytesIO()
+    with ZipFile(BytesIO(scrubbed), "r") as original, ZipFile(
+        enriched,
+        "w",
+        ZIP_DEFLATED,
+    ) as output:
+        for entry in original.infolist():
+            output.writestr(entry, original.read(entry.filename))
+        output.writestr(marker_path, marker_bytes)
+
+    result = reinsert_docx_bytes(enriched.getvalue(), _scrub_key())
+
+    with ZipFile(BytesIO(result["docx_bytes"]), "r") as restored:
+        assert restored.read(marker_path) == marker_bytes
+
+
+def test_invalid_header_xml_returns_validation_issue_without_partial_output() -> None:
+    source = _source_docx()
+    broken = BytesIO()
+    with ZipFile(BytesIO(source), "r") as original, ZipFile(
+        broken,
+        "w",
+        ZIP_DEFLATED,
+    ) as output:
+        for entry in original.infolist():
+            data = original.read(entry.filename)
+            if entry.filename.startswith("word/header") and entry.filename.endswith(".xml"):
+                data = b"<w:hdr>"
+            output.writestr(entry, data)
+
+    result = reinsert_docx_bytes(broken.getvalue(), _scrub_key())
+
+    assert result["reinserted"] is False
+    assert result["replacement_count"] == 0
+    assert result["validation_issues"]
+    assert "header" in result["validation_issues"][0].lower()
+    assert result["docx_bytes"] == broken.getvalue()
+
+
+def test_pdf_ocr_and_restored_pdf_scope_are_not_added() -> None:
+    source = Path("MVP_PHASE6_FALSE_NEGATIVE_GAP_TRIAGE.md").read_text(encoding="utf-8")
+
+    assert "restored-TXT-only" in source
+    assert "No OCR or restored-PDF implementation is authorized" in source

tests/test_mvp_phase6_e2e_synthetic_validation_matrix.py

@@ -117,7 +117,7 @@ def test_txt_detection_evidence_covers_expected_values_and_preserves_roles() ->
     )
 
 
-def test_docx_case_records_hygiene_and_header_footer_reinsert_limits() -> None:
+def test_docx_case_restores_header_footer_and_retains_hygiene_evidence() -> None:
     case = _case(_report(), "docx_mixed_structure_roundtrip")
 
     assert case["status"] == "pass_with_known_limitations"
@@ -125,16 +125,20 @@ def test_docx_case_records_hygiene_and_header_footer_reinsert_limits() -> None:
     assert case["scrubbed_import_type"] == "docx"
     assert case["restored_import_type"] == "docx"
     assert case["body_roundtrip_values_present"] is True
+    assert case["header_footer_roundtrip_values_present"] is True
     assert case["hygiene_severity"] == "high"
     assert {"headers_detected", "footers_detected"}.issubset(
         set(case["hygiene_findings"])
     )
     assert case["audit_expectations_met"] is True
     assert case["limitation_expectations_met"] is True
-    assert case["roundtrip_complete"] is False
-    assert set(case["expected_residual_placeholders"]).issubset(
-        set(case["residual_placeholders"])
+    assert case["roundtrip_complete"] is True
+    assert case["residual_placeholders"] == []
+    assert set(case["expected_residual_placeholders"]) == set(
+        case["resolved_header_footer_placeholders"]
     )
+    assert any(part.startswith("word/header") for part in case["processed_parts"])
+    assert any(part.startswith("word/footer") for part in case["processed_parts"])
 
 
 def test_pdf_case_preserves_text_roundtrip_and_explicit_txt_only_boundary() -> None:
@@ -171,10 +175,7 @@ def test_report_is_machine_readable_and_never_claims_production_readiness() -> N
     )
 
     categories = {item["category"] for item in report["evidence_gaps"]}
-    assert categories == {
-        "known_docx_reinsert_limitation",
-        "known_pdf_reinsert_limitation",
-    }
+    assert categories == {"known_pdf_reinsert_limitation"}
 
 
 def test_report_writer_is_deterministic(tmp_path: Path) -> None:

workpackage_claims/scrub_wp_mvp_document_hygiene_fidelity_hardening.md

@@ -0,0 +1,52 @@
+# Workpackage claim — SCRUB-WP_MVP_DOCUMENT_HYGIENE_FIDELITY_HARDENING
+
+Repository: solidprivacy-nl/scrub
+
+Workpackage title: SCRUB-WP_MVP_DOCUMENT_HYGIENE_FIDELITY_HARDENING
+
+Status: completed / ready for app verification
+
+Claimed by: ChatGPT GitHub worker
+
+Claimed at: 2026-07-17 22:30 Europe/Amsterdam
+
+Branch: scrub-mvp-document-hygiene-fidelity-hardening
+
+Dependencies:
+- SCRUB-WP_MVP_E2E_SYNTHETIC_VALIDATION_MATRIX — merged.
+- SCRUB-WP_MVP_FALSE_NEGATIVE_GAP_TRIAGE — merged.
+
+Evidence:
+- DOCX body/table reinsert passes, while scrubbed header/footer placeholders remain after reinsert.
+- DOCX hygiene audit already reports header/footer presence.
+- PDF text roundtrip passes only to restored TXT; restored PDF and OCR remain unsupported product boundaries.
+
+Scope:
+- Harden deterministic DOCX reinsert fidelity for existing scrubbed header and footer OOXML parts.
+- Add contract and regression tests covering document body, tables, headers and footers.
+- Preserve explicit unsupported boundaries for comments, tracked changes, metadata, split placeholders, OCR and restored PDF.
+- Update the Phase 6 matrix expectation and evidence after the helper change.
+
+Boundaries:
+- Helper-level document reinsert plus capability-copy alignment only; no new Streamlit controls or flow.
+- No recognizer, threshold or replacement changes.
+- No export filename, MIME or Scrub Key schema changes.
+- No comments/tracked changes/metadata cleaning guarantee.
+- No OCR or restored-PDF implementation.
+- Synthetic data only; local-only deterministic processing.
+
+Next step:
+- Run final PR validation, merge after green Actions, verify Hugging Face sync and request live DOCX reinsert verification.
+
+
+Hardening result:
+- Completed at: 2026-07-17 22:30 Europe/Amsterdam
+- DOCX header/footer reinsert resolved: true
+- Resolved findings: 1
+- Remaining findings: 1
+- Report: `output/validation/mvp_phase6_document_hygiene_fidelity_hardening_report.json`
+- Handover: `handover/workpackages/20260717_2230_mvp_document_hygiene_fidelity_hardening.md`
+- App verification required after Actions and Hugging Face sync.
+
+Final PR cleanup:
+- Temporary patch/finalizer scripts removed and duplicate governance lines normalized before the final Actions run.