Improve contextual PII masking and regression coverage

src/pii_mixed_regression_cases.json

@@ -0,0 +1,446 @@
+{
+  "synthetic": true,
+  "policy": "Invented regression examples; no corpus excerpts or document references. Email and web domains use example.com. Phone/identifier values test syntax, not assignment; public emergency codes retain their literal semantics.",
+  "cases": [
+    {
+      "name": "vanity_phone",
+      "text": "Biuro Przykład, ☏ +1 202 555-TEST (8378), +1 202 555-0142.",
+      "mask": [
+        {
+          "start": 18,
+          "end": 40,
+          "text": "+1 202 555-TEST (8378)",
+          "label": "phone"
+        },
+        {
+          "start": 42,
+          "end": 57,
+          "text": "+1 202 555-0142",
+          "label": "phone"
+        }
+      ],
+      "preserve": []
+    },
+    {
+      "name": "email_space_inside_domain",
+      "text": "Kontakt: osoba@sub- domena.example.com.",
+      "mask": [
+        {
+          "start": 9,
+          "end": 38,
+          "text": "osoba@sub- domena.example.com",
+          "label": "pii"
+        }
+      ],
+      "preserve": []
+    },
+    {
+      "name": "shared_area_code_phone_pair",
+      "text": "Restauracja Przykład, ulica Przykładowa 12. ☎ (8426) 23-45-61, 23-45-62. Godziny 10.00-22.00.",
+      "mask": [
+        {
+          "start": 46,
+          "end": 61,
+          "text": "(8426) 23-45-61",
+          "label": "phone"
+        },
+        {
+          "start": 63,
+          "end": 71,
+          "text": "23-45-62",
+          "label": "phone"
+        }
+      ],
+      "preserve": [
+        {
+          "start": 81,
+          "end": 92,
+          "text": "10.00-22.00"
+        }
+      ]
+    },
+    {
+      "name": "email_domain_line_break",
+      "text": "Autor przykładowego artykułu (autor@poczta.\nexample.com).\nTytuł publikacji.",
+      "mask": [
+        {
+          "start": 30,
+          "end": 55,
+          "text": "autor@poczta.\nexample.com",
+          "label": "pii"
+        }
+      ],
+      "preserve": []
+    },
+    {
+      "name": "international_trunk_in_business_listing",
+      "text": "Kemping Przykład, +27 (0)13 234-5612 oferuje noclegi.\n\nKemping Testowy +27 (0)13 234-5613 ma basen.",
+      "mask": [
+        {
+          "start": 18,
+          "end": 36,
+          "text": "+27 (0)13 234-5612",
+          "label": "phone"
+        },
+        {
+          "start": 71,
+          "end": 89,
+          "text": "+27 (0)13 234-5613",
+          "label": "phone"
+        }
+      ],
+      "preserve": []
+    },
+    {
+      "name": "emergency_number_lists",
+      "text": "Biuro testowe, tel. 22 123-45-67, tel. alarmowe 997 i 112.\n\nStraż pożarna\ntel. 22 123-45-68, tel. alarmowe 998 i 112.",
+      "mask": [
+        {
+          "start": 48,
+          "end": 51,
+          "text": "997",
+          "label": "phone"
+        },
+        {
+          "start": 54,
+          "end": 57,
+          "text": "112",
+          "label": "phone"
+        },
+        {
+          "start": 107,
+          "end": 110,
+          "text": "998",
+          "label": "phone"
+        },
+        {
+          "start": 113,
+          "end": 116,
+          "text": "112",
+          "label": "phone"
+        }
+      ],
+      "preserve": []
+    },
+    {
+      "name": "emergency_directory_labels",
+      "text": "Numery telefonów\nW sytuacjach awaryjnych\nStraż pożarna: 122\nPolicja: 133\nRatunek: 144\nLekarz pogotowia ratunkowego: 141",
+      "mask": [
+        {
+          "start": 82,
+          "end": 85,
+          "text": "144",
+          "label": "phone"
+        },
+        {
+          "start": 116,
+          "end": 119,
+          "text": "141",
+          "label": "phone"
+        }
+      ],
+      "preserve": []
+    },
+    {
+      "name": "foreign_short_service_directory",
+      "text": "W przypadku pytań i problemów\nBiuro podróży Przykład: +43 (0)5 2345\nObsługa rzeczy znalezionych: +43 (0)1 23 456 78 23 456\nAwaria automatów: +43 (0)5 2345 67\nSiedziba administracji: +43 (0)1 23456\nInformacje można uzyskać dzwoniąc pod numer biura podróży +43 (0)5 2345.",
+      "mask": [
+        {
+          "start": 54,
+          "end": 67,
+          "text": "+43 (0)5 2345",
+          "label": "phone"
+        },
+        {
+          "start": 97,
+          "end": 122,
+          "text": "+43 (0)1 23 456 78 23 456",
+          "label": "phone"
+        },
+        {
+          "start": 141,
+          "end": 157,
+          "text": "+43 (0)5 2345 67",
+          "label": "phone"
+        },
+        {
+          "start": 182,
+          "end": 196,
+          "text": "+43 (0)1 23456",
+          "label": "phone"
+        },
+        {
+          "start": 255,
+          "end": 268,
+          "text": "+43 (0)5 2345",
+          "label": "phone"
+        }
+      ],
+      "preserve": []
+    },
+    {
+      "name": "email_space_after_at",
+      "text": "Faks: +81 23-456-7812, biuro@ sub.example.com. Godziny 09:00-18:00.",
+      "mask": [
+        {
+          "start": 23,
+          "end": 45,
+          "text": "biuro@ sub.example.com",
+          "label": "pii"
+        }
+      ],
+      "preserve": [
+        {
+          "start": 55,
+          "end": 66,
+          "text": "09:00-18:00"
+        }
+      ]
+    },
+    {
+      "name": "phone_symbol_with_foreign_area_code",
+      "text": "Punkt Przykład. ☎ (384) 234 - 56 - 71. Godziny 10:00-22:00.",
+      "mask": [
+        {
+          "start": 18,
+          "end": 37,
+          "text": "(384) 234 - 56 - 71",
+          "label": "phone"
+        }
+      ],
+      "preserve": [
+        {
+          "start": 47,
+          "end": 58,
+          "text": "10:00-22:00"
+        }
+      ]
+    },
+    {
+      "name": "phone_stops_before_street_number",
+      "text": "Restauracja Przykład, ☏ +86 574-2345-6712. 87 ulica Przykładowa. Opis lokalu.",
+      "mask": [
+        {
+          "start": 24,
+          "end": 41,
+          "text": "+86 574-2345-6712",
+          "label": "phone"
+        }
+      ],
+      "preserve": [
+        {
+          "start": 41,
+          "end": 45,
+          "text": ". 87"
+        }
+      ]
+    },
+    {
+      "name": "five_digit_helpline",
+      "text": "Informacje o usłudze.\n\nInfolinia Centrum Przykład (dla zgłoszeń produkcyjnych): 19 876\n\nDalszy opis usługi.",
+      "mask": [
+        {
+          "start": 80,
+          "end": 86,
+          "text": "19 876",
+          "label": "phone"
+        }
+      ],
+      "preserve": []
+    },
+    {
+      "name": "epuap_list_with_lub",
+      "text": "Skrytki ePUAP: /przyklad123/skrytka lub /przyklad123/SkrytkaESP, albo\nadres e-mail: biuro@example.com.",
+      "mask": [
+        {
+          "start": 15,
+          "end": 35,
+          "text": "/przyklad123/skrytka",
+          "label": "pii"
+        },
+        {
+          "start": 40,
+          "end": 63,
+          "text": "/przyklad123/SkrytkaESP",
+          "label": "pii"
+        },
+        {
+          "start": 84,
+          "end": 101,
+          "text": "biuro@example.com",
+          "label": "pii"
+        }
+      ],
+      "preserve": []
+    },
+    {
+      "name": "microcontroller_is_not_iban",
+      "text": "The test device uses the AD0227 microcontroller and transmits sample data.",
+      "mask": [],
+      "preserve": [
+        {
+          "start": 25,
+          "end": 51,
+          "text": "AD0227 microcontroller and"
+        }
+      ]
+    },
+    {
+      "name": "helpline_and_support_line_context",
+      "text": "Całodobowy telefon w sprawie pomocy – 116 789 oraz Linię Wsparcia dla Uczestników - 22 123 45 67.\n\nOsoby dzwoniące na numer 116 789 otrzymują informacje.",
+      "mask": [
+        {
+          "start": 38,
+          "end": 45,
+          "text": "116 789",
+          "label": "phone"
+        },
+        {
+          "start": 84,
+          "end": 96,
+          "text": "22 123 45 67",
+          "label": "phone"
+        },
+        {
+          "start": 124,
+          "end": 131,
+          "text": "116 789",
+          "label": "phone"
+        }
+      ],
+      "preserve": []
+    },
+    {
+      "name": "phone_range_suffix",
+      "text": "Centrum Przykład, ulica Testowa 12, telefon centrala: 048/ 234 56 71 do 73.\nDalszy opis działalności.",
+      "mask": [
+        {
+          "start": 54,
+          "end": 74,
+          "text": "048/ 234 56 71 do 73",
+          "label": "phone"
+        }
+      ],
+      "preserve": []
+    },
+    {
+      "name": "short_foreign_emergency_numbers",
+      "text": "Placówka Przykład, ☏ +49341 2345-6, numer bezpłatny: 110 (w nagłych wypadkach).\nPlacówka Testowa, ☏ +49341987-65432, bezpłatny: 110 (w nagłych wypadkach).",
+      "mask": [
+        {
+          "start": 53,
+          "end": 56,
+          "text": "110",
+          "label": "phone"
+        },
+        {
+          "start": 128,
+          "end": 131,
+          "text": "110",
+          "label": "phone"
+        }
+      ],
+      "preserve": []
+    },
+    {
+      "name": "blik_phone_contact",
+      "text": "Można przesłać środki Blikiem: 794 23 45 67 z dopiskiem Test.\n\nDalsze informacje.",
+      "mask": [
+        {
+          "start": 31,
+          "end": 43,
+          "text": "794 23 45 67",
+          "label": "phone"
+        }
+      ],
+      "preserve": []
+    },
+    {
+      "name": "phone_before_price",
+      "text": "Bar Przykład, ulica Testowa 12, ☎ +39552345671. 3,00 € za przekąskę. 9-19.",
+      "mask": [
+        {
+          "start": 34,
+          "end": 46,
+          "text": "+39552345671",
+          "label": "phone"
+        }
+      ],
+      "preserve": [
+        {
+          "start": 48,
+          "end": 54,
+          "text": "3,00 €"
+        },
+        {
+          "start": 69,
+          "end": 73,
+          "text": "9-19"
+        }
+      ]
+    },
+    {
+      "name": "url_query_digits_are_not_pesel",
+      "text": "https://example.com/article/?doing_wp_cron=1234567890.44051401458\n12345678901.\nPrzykładowy przypis.",
+      "mask": [],
+      "preserve": [
+        {
+          "start": 54,
+          "end": 65,
+          "text": "44051401458"
+        }
+      ]
+    },
+    {
+      "name": "six_digit_helpline",
+      "text": "Informacja o finansowaniu dla telefonu zaufania, 116 789, jest dostępna w raporcie.",
+      "mask": [
+        {
+          "start": 49,
+          "end": 56,
+          "text": "116 789",
+          "label": "phone"
+        }
+      ],
+      "preserve": []
+    },
+    {
+      "name": "foreign_mobile_dotted_format",
+      "text": "Ośrodek Przykład, ulica Testowa 12. Tel 075.2345671 Tel. komórkowy 347.2345671. Dalszy opis.",
+      "mask": [
+        {
+          "start": 67,
+          "end": 78,
+          "text": "347.2345671",
+          "label": "phone"
+        }
+      ],
+      "preserve": []
+    },
+    {
+      "name": "trademark_registration_is_not_pii",
+      "text": "Przykładowy znak towarowy o numerze R-234567 jest chroniony do 2027 roku.",
+      "mask": [],
+      "preserve": [
+        {
+          "start": 36,
+          "end": 44,
+          "text": "R-234567"
+        }
+      ]
+    },
+    {
+      "name": "ordinary_phone_keeps_phone_label",
+      "text": "Biuro Przykład, ☏ +1 202 555-0142, numer bezpłatny: +1 202 555-0143.",
+      "mask": [
+        {
+          "start": 52,
+          "end": 67,
+          "text": "+1 202 555-0143",
+          "label": "phone"
+        }
+      ],
+      "preserve": []
+    }
+  ]
+}

src/pii_wikivoyage_regression_cases.json

@@ -0,0 +1,415 @@
+{
+  "synthetic": true,
+  "policy": "Invented regression examples; no corpus excerpts or document references. Email and web domains use example.com. Phone/identifier values test syntax, not assignment; public emergency codes retain their literal semantics.",
+  "cases": [
+    {
+      "name": "wikivoyage_thai_dialling_and_fax_list",
+      "text": "Kontakt\n\nPlacówka Przykład\n\nBudynek 123-125, piętro 4\n\nUlica Testowa, 12345 Miasto\n\nStrona www: https://example.com/\n\nTelefony:\n\nCentrala placówki\n\n- dzwoniąc z Polski z tel. stacjonarnego 0066 2 234 5612\n\n- dzwoniąc z Polski z tel. komórkowego +66 2 234 5612\n\n- dzwoniąc z Tajlandii z tel. lokalnego 0 2 234 5612\n\nFax:\n\n- z Polski 0066 2 234 5613\n\n- z Tajlandii 0 2 234 5613\n\nAdresy e-mail:\n\nSekretariat: sekretariat@example.com\n\nBiuro: biuro@example.com\n\nInna placówka\n\nUlica Testowa 2, D - 12345 Miasto\n\nTelefon: +49 30 23 45 67 12\n\nFax: +49 30 23 45 67 13\n\nhttps://branch.example.com\n\nE-mail: kontakt@branch.example.com",
+      "mask": [
+        {
+          "start": 189,
+          "end": 204,
+          "text": "0066 2 234 5612",
+          "label": "phone"
+        },
+        {
+          "start": 245,
+          "end": 259,
+          "text": "+66 2 234 5612",
+          "label": "phone"
+        },
+        {
+          "start": 301,
+          "end": 313,
+          "text": "0 2 234 5612",
+          "label": "phone"
+        },
+        {
+          "start": 332,
+          "end": 347,
+          "text": "0066 2 234 5613",
+          "label": "phone"
+        },
+        {
+          "start": 363,
+          "end": 375,
+          "text": "0 2 234 5613",
+          "label": "phone"
+        },
+        {
+          "start": 406,
+          "end": 429,
+          "text": "sekretariat@example.com",
+          "label": "pii"
+        },
+        {
+          "start": 438,
+          "end": 455,
+          "text": "biuro@example.com",
+          "label": "pii"
+        },
+        {
+          "start": 516,
+          "end": 534,
+          "text": "+49 30 23 45 67 12",
+          "label": "phone"
+        },
+        {
+          "start": 541,
+          "end": 559,
+          "text": "+49 30 23 45 67 13",
+          "label": "phone"
+        },
+        {
+          "start": 597,
+          "end": 623,
+          "text": "kontakt@branch.example.com",
+          "label": "pii"
+        }
+      ],
+      "preserve": [
+        {
+          "start": 36,
+          "end": 43,
+          "text": "123-125"
+        },
+        {
+          "start": 70,
+          "end": 75,
+          "text": "12345"
+        },
+        {
+          "start": 489,
+          "end": 498,
+          "text": "D - 12345"
+        }
+      ]
+    },
+    {
+      "name": "wikivoyage_italian_restaurant_directory",
+      "text": "Restauracje:\nLokal Alfa, ulica Testowa 12, +39 0575-234561. 19:00-23:00. 15-30 EUR.\nLokal Beta, ulica Testowa 14, ☏ + 39-0575 23456. Opis restauracji.\nLokal Gamma, ulica Testowa 16, ☏ +39 0575234567. Menu za 25 lub 20 €.\nLokal Delta, ulica Testowa 18, ☏ +39 0575 23457. Oferta lokalu.\n\nNapoje\nLokal Epsilon, ulica Testowa 20, ☏ +39 057523458. 11:30-24:00. 15-30 EUR.\nLokal Zeta, ulica Testowa 22. 06:00-20:30. Opis przykładowej oferty.\nLokal Eta, ulica Testowa 24, +39 0575 234562. Opis lokalu.\n\nFestiwale",
+      "mask": [
+        {
+          "start": 116,
+          "end": 131,
+          "text": "+ 39-0575 23456",
+          "label": "phone"
+        },
+        {
+          "start": 184,
+          "end": 198,
+          "text": "+39 0575234567",
+          "label": "phone"
+        },
+        {
+          "start": 254,
+          "end": 268,
+          "text": "+39 0575 23457",
+          "label": "phone"
+        },
+        {
+          "start": 328,
+          "end": 341,
+          "text": "+39 057523458",
+          "label": "phone"
+        },
+        {
+          "start": 465,
+          "end": 480,
+          "text": "+39 0575 234562",
+          "label": "phone"
+        }
+      ],
+      "preserve": [
+        {
+          "start": 208,
+          "end": 219,
+          "text": "25 lub 20 €"
+        },
+        {
+          "start": 343,
+          "end": 354,
+          "text": "11:30-24:00"
+        },
+        {
+          "start": 397,
+          "end": 408,
+          "text": "06:00-20:30"
+        }
+      ]
+    },
+    {
+      "name": "wikivoyage_chinese_hotel_directory",
+      "text": "Hotel Alfa, ulica Testowa 12, ☏ +86 351 2345612.\nHotel Beta, 115 ulica Testowa. Pokoje z dostępem do sieci. Cena od 188¥.\nHotel Gamma, 99 ulica Testowa, +86 351 2345613.\n\nUmiarkowanie\nHotel Delta, ulica Testowa 14, ☏ +86 351 2345614, faks: +86 351 2345615.\nHotel Epsilon, ulica Testowa 16, ☏ +86 351 2345616, faks: +86 351 2345617.\nHotel Zeta, ulica Testowa 18, ☏ +86 351 2345618, faks: +86 351 2345619.\n\nEkskluzywnie\nHotel Eta, ulica Testowa 20, ☏ +86 351 2345621.\nHotel Theta, ulica Testowa 22, +86-21-23456712 wew. 1234, rezerwacja@example.com. 5-gwiazdkowy hotel z restauracją.\n\nKontakt",
+      "mask": [
+        {
+          "start": 153,
+          "end": 168,
+          "text": "+86 351 2345613",
+          "label": "phone"
+        },
+        {
+          "start": 217,
+          "end": 232,
+          "text": "+86 351 2345614",
+          "label": "phone"
+        },
+        {
+          "start": 240,
+          "end": 255,
+          "text": "+86 351 2345615",
+          "label": "phone"
+        },
+        {
+          "start": 292,
+          "end": 307,
+          "text": "+86 351 2345616",
+          "label": "phone"
+        },
+        {
+          "start": 315,
+          "end": 330,
+          "text": "+86 351 2345617",
+          "label": "phone"
+        },
+        {
+          "start": 364,
+          "end": 379,
+          "text": "+86 351 2345618",
+          "label": "phone"
+        },
+        {
+          "start": 387,
+          "end": 402,
+          "text": "+86 351 2345619",
+          "label": "phone"
+        },
+        {
+          "start": 449,
+          "end": 464,
+          "text": "+86 351 2345621",
+          "label": "phone"
+        },
+        {
+          "start": 497,
+          "end": 522,
+          "text": "+86-21-23456712 wew. 1234",
+          "label": "phone"
+        },
+        {
+          "start": 524,
+          "end": 546,
+          "text": "rezerwacja@example.com",
+          "label": "pii"
+        }
+      ],
+      "preserve": [
+        {
+          "start": 61,
+          "end": 78,
+          "text": "115 ulica Testowa"
+        },
+        {
+          "start": 116,
+          "end": 120,
+          "text": "188¥"
+        },
+        {
+          "start": 135,
+          "end": 151,
+          "text": "99 ulica Testowa"
+        },
+        {
+          "start": 548,
+          "end": 560,
+          "text": "5-gwiazdkowy"
+        }
+      ]
+    },
+    {
+      "name": "wikivoyage_labelled_damaged_phone",
+      "text": "Wstęp na teren ośrodka:\nWejście w godz. 7.00-18.00\nNormalny – 4,00 zł\nPowierzchnia 2040 ha.\n\nGastronomia\nRestauracje, pizzerie\nLokal Alfa, ulica Testowa 12; tel. 77-234-56-712\nLokal Beta; tel. 77 234 56 71\nLokal Gamma; tel. 77-234-56-72\nLokal Delta; tel. 77-234-56-73\nLokal Epsilon; tel. 77-234-56-74\nLokal Zeta; tel: 77-234-56-75\nLokal Eta; tel: 77-234-56-76\nLokal Theta, tel. 730234567\nLokal Iota, tel. 77 2345677\nLokal Kappa, tel 602234571\nLokal Lambda, tel. 77 2345678\n\nPuby\nLokal Mu; tel. 77-234-56-79\nLokal Nu; tel. []",
+      "mask": [
+        {
+          "start": 162,
+          "end": 175,
+          "text": "77-234-56-712",
+          "label": "phone"
+        },
+        {
+          "start": 193,
+          "end": 205,
+          "text": "77 234 56 71",
+          "label": "phone"
+        },
+        {
+          "start": 224,
+          "end": 236,
+          "text": "77-234-56-72",
+          "label": "phone"
+        },
+        {
+          "start": 255,
+          "end": 267,
+          "text": "77-234-56-73",
+          "label": "phone"
+        },
+        {
+          "start": 288,
+          "end": 300,
+          "text": "77-234-56-74",
+          "label": "phone"
+        },
+        {
+          "start": 318,
+          "end": 330,
+          "text": "77-234-56-75",
+          "label": "phone"
+        },
+        {
+          "start": 347,
+          "end": 359,
+          "text": "77-234-56-76",
+          "label": "phone"
+        },
+        {
+          "start": 378,
+          "end": 387,
+          "text": "730234567",
+          "label": "phone"
+        },
+        {
+          "start": 405,
+          "end": 415,
+          "text": "77 2345677",
+          "label": "phone"
+        },
+        {
+          "start": 433,
+          "end": 442,
+          "text": "602234571",
+          "label": "phone"
+        },
+        {
+          "start": 462,
+          "end": 472,
+          "text": "77 2345678",
+          "label": "phone"
+        },
+        {
+          "start": 494,
+          "end": 506,
+          "text": "77-234-56-79",
+          "label": "phone"
+        }
+      ],
+      "preserve": [
+        {
+          "start": 40,
+          "end": 50,
+          "text": "7.00-18.00"
+        },
+        {
+          "start": 62,
+          "end": 69,
+          "text": "4,00 zł"
+        },
+        {
+          "start": 83,
+          "end": 90,
+          "text": "2040 ha"
+        }
+      ]
+    },
+    {
+      "name": "wikivoyage_hungarian_hotel_directory",
+      "text": "Hotel Alfa, ulica Testowa 12, ☏ +36 84 234561, ✉ alfa@example.com. Pokój Ft 18 000–27 000.\nHotel Beta, ulica Testowa 14, ☏ +36 30 2345671. Zameldowanie: 10:00, wymeldowanie: 14:00.\nHotel Gamma, ulica Testowa 16, ☏ +36 84 234 562, ✉ gamma@example.com. Dodatkowe łóżko Ft 4500-11500.\nHotel Delta, ulica Testowa 18, delta@example.com. Od 15 € / noc / osoba.\nHotel Epsilon, ulica Testowa 20, ✉ epsilon@example.com. 14-27 € / noc / osoba.\nHotel Zeta, restauracja i bar, ulica Testowa 22, +36 84 234 563. Oferta noclegów.",
+      "mask": [
+        {
+          "start": 123,
+          "end": 137,
+          "text": "+36 30 2345671",
+          "label": "phone"
+        },
+        {
+          "start": 214,
+          "end": 228,
+          "text": "+36 84 234 562",
+          "label": "phone"
+        },
+        {
+          "start": 232,
+          "end": 249,
+          "text": "gamma@example.com",
+          "label": "pii"
+        },
+        {
+          "start": 313,
+          "end": 330,
+          "text": "delta@example.com",
+          "label": "pii"
+        },
+        {
+          "start": 390,
+          "end": 409,
+          "text": "epsilon@example.com",
+          "label": "pii"
+        },
+        {
+          "start": 483,
+          "end": 497,
+          "text": "+36 84 234 563",
+          "label": "phone"
+        }
+      ],
+      "preserve": [
+        {
+          "start": 73,
+          "end": 89,
+          "text": "Ft 18 000–27 000"
+        },
+        {
+          "start": 267,
+          "end": 280,
+          "text": "Ft 4500-11500"
+        }
+      ]
+    },
+    {
+      "name": "wikivoyage_qualified_mobile_label",
+      "text": "Nauka\nSzkoła Przykład oferuje kursy od 1 tygodnia/20 godzin do 4 tygodni/80 godzin (~360 USD). Kontakt: nauka@example.com.\nZajęcia taneczne w szkole Testowej. Kontakt: taniec@example.com. Telefon komórkowy: (53) 05 234567123.\n\nZakupy\nPrzykładowe informacje o mieście.",
+      "mask": [
+        {
+          "start": 104,
+          "end": 121,
+          "text": "nauka@example.com",
+          "label": "pii"
+        },
+        {
+          "start": 168,
+          "end": 186,
+          "text": "taniec@example.com",
+          "label": "pii"
+        },
+        {
+          "start": 207,
+          "end": 224,
+          "text": "(53) 05 234567123",
+          "label": "phone"
+        }
+      ],
+      "preserve": [
+        {
+          "start": 39,
+          "end": 59,
+          "text": "1 tygodnia/20 godzin"
+        },
+        {
+          "start": 84,
+          "end": 92,
+          "text": "~360 USD"
+        }
+      ]
+    }
+  ]
+}

src/scrub_pii.py

@@ -1,9 +1,23 @@
 """Regex PII scrub for Polish web/official text.
 
-Replaces emails, phones, PESEL/NIP/REGON and account numbers in place so
+Replaces emails, phones, PESEL/NIP/REGON/KRS, electronic contact addresses and account numbers in place so
 sentence structure survives. Names of public officials are left untouched —
 that is intentional, not a gap. Phones map to [Telefon]; everything else
-to [PII]. Checksums gate the national IDs so statute and case numbers stay.
+to [PII]. Bare PESEL requires checksum and date validation; explicit identifier
+labels also redact damaged numbers (including common OCR O/I/l substitutions).
+NIP/REGON/KRS and identity documents require explicit nearby labels. Passport
+variants include one-letter and diplomatic IDs. Foreign IBANs use country
+lengths and MOD-97. ePUAP paths require a label; e-Doreczenia uses its AE:PL form.
+Wrapped email domains and small extraction gaps around @/hyphens are supported.
+Explicit phone extensions and terminal suffix ranges are included; room numbers are not. Labelled numeric
+PINs (including URL pin= values) map to [PII] before phone detection.
+Contact/helpline headings cover consecutive descriptive phone-list entries;
+unrelated lines end the list. Bounded staff/address-directory evidence also covers
+formatted phone fields. Labelled full-number ranges retain shared prefixes.
+Phones require a nearby contact cue, a Polish +48/0048 prefix, or explicit
+international country/trunk notation such as +CC (0). Short service numbers
+need strong labels; 116xxx numbers also accept nearby telephone prose. Unlabelled
+domestic numbers are left for audit because table cells have the same shapes.
 
 Call after HTML-to-text, before the parquet is written.
 """
@@ -13,12 +27,12 @@ import re
 
 PHONE_TAG = "[Telefon]"
 PII_TAG = "[PII]"
-COUNTS = ("email", "phone", "pesel", "nip", "regon", "account")
+COUNTS = ("email", "phone", "pesel", "nip", "regon", "account", "document", "krs", "electronic_address", "pin")
 
 # Mobile + geographic area codes (2-digit national prefix after trunk 0 / +48).
 _PL_PREFIX = {
-    "12", "13", "14", "15", "16", "17", "18", "22", "23", "24", "25", "29",
-    "32", "33", "34", "39", "41", "42", "43", "44", "45", "46", "48",
+    "12", "13", "14", "15", "16", "17", "18", "22", "23", "24", "25", "26", "29",
+    "32", "33", "34", "39", "41", "42", "43", "44", "45", "46", "47", "48",
     "50", "51", "52", "53", "54", "55", "56", "57", "58", "59",
     "60", "61", "62", "63", "65", "66", "67", "68", "69",
     "70", "71", "72", "73", "74", "75", "76", "77", "78", "79",
@@ -26,22 +40,258 @@ _PL_PREFIX = {
     "91", "94", "95",
 }
 
-_EMAIL_RE = re.compile(r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b")
+_EMAIL_DOMAIN = r"[^\W_](?:[^\W_]|-[ \t]{0,3}(?=[^\W_]))*"
+_EMAIL_START = r"\b[\w.%+&-]+[ \t]{0,3}@"
+_EMAIL_RE = re.compile(_EMAIL_START + r"[ \t]{0,3}(?:" + _EMAIL_DOMAIN + r"\.)+[^\W\d_]{2,}\b")
+_EMAIL_WRAP_RE = re.compile(_EMAIL_START + r"[ \t]{0,3}(?:" + _EMAIL_DOMAIN
+    + r"\.)+[ \t]*\r?\n[ \t]*(?:" + _EMAIL_DOMAIN + r"\.)*[^\W\d_]{2,}\b")
+# Damaged contact fields can retain only the local part and @.
+_EMAIL_FRAGMENT_RE = re.compile(_EMAIL_START + r"(?=[ \t]*\r?$)", re.M)
+_EMAIL_LABEL_RE = re.compile(r"\be[ -]?mail[ \t]*:[ \t]*\Z", re.I)
+_EDELIVERY_RE = re.compile(r"\bAE:PL-\d{5}-\d{5}-[A-Z0-9]{5}-\d{2}(?![\w-])", re.I)
+_EPUAP_RE = re.compile(r"(?<![\w/])/[\w-]+/[\w-]+(?![\w/-])")
+_EPUAP_LABEL_RE = re.compile(
+    r"\b(?:e[ -]?puap|elektroniczna[ \t]+skrzynka[ \t]+podawcza)\b[^\n/\[\]]{0,50}\Z", re.I)
+_PIN_RE = re.compile(
+    r"(?P<label>\bPIN[ \t]*[:=][ \t]*)"
+    r"(?P<number>[\u202a-\u202e\u2066-\u2069]*\d(?:[ \t]?\d){3,15}#?)"
+    r"(?!\w|[ \t]*\d)", re.I)
+# Horizontal Unicode spaces from HTML/PDF extraction; preserve paragraph breaks.
+_SPACES = str.maketrans({c: " " for c in "\u00a0\u1680\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000"})
+# Country lengths checked against Apache Commons Validator's IBAN registry table:
+# https://commons.apache.org/proper/commons-validator/xref/org/apache/commons/validator/routines/IBANValidator.html
+# ponytail: country/length/MOD-97 only; add national BBAN rules if false positives appear.
+_IBAN_LENGTHS = {
+    country: length for length, countries in {
+        15: "NO", 16: "BE", 18: "DK FI AX FK FO GL NL SD",
+        19: "MK SI", 20: "AT BA EE KZ LT LU MN XK",
+        21: "CH HR LI LV", 22: "BG BH CR DE GB IM JE GG GE IE ME RS VA",
+        23: "AE GI IL IQ OM SO TL", 24: "AD CZ ES MD PK RO SA SE SK TN VG",
+        25: "LY PT ST", 26: "IS TR",
+        27: "BI DJ FR GF GP MQ RE PF TF YT NC BL MF PM WF GR IT MC MR SM",
+        28: "AL AZ BY CY DO GT HN HU LB NI PL SV", 29: "BR EG PS QA UA",
+        30: "JO KW MU YE", 31: "MT SC", 32: "LC", 33: "RU",
+    }.items() for country in countries.split()
+}
+_IBAN_RE = re.compile(
+    r"\b(?:" + "|".join(
+        country + r"[ \t-]*[0-9]{2}(?:[ \t-]*[A-Z0-9]){" + str(length - 4) + "}"
+        for country, length in _IBAN_LENGTHS.items()
+    ) + r")\b", re.I,
+)
 # Optional PL, then 26 digits with short space/tab/hyphen gaps (invoice style).
 _ACCOUNT_RE = re.compile(r"\b(?:PL[ \t-]*)?(?:\d[ \t-]*){25}\d\b", re.I)
 _REGON14_RE = re.compile(r"\b\d{14}\b")
 _PESEL_RE = re.compile(r"\b\d{11}\b")
-_NIP_DASH_RE = re.compile(r"\b\d{3}[-\s]\d{3}[-\s]\d{2}[-\s]\d{2}\b")
-_NIP_RE = re.compile(r"\b\d{10}\b")
+_NIP_DASH_RE = re.compile(r"\b(?:PL[ \t]*)?\d{3}(?:[- \t]\d{3}[- \t]\d{2}[- \t]\d{2}|[- \t]\d{2}[- \t]\d{2}[- \t]\d{3})\b", re.I)
+_NIP_RE = re.compile(r"\b(?:PL[ \t]*)?\d{10}\b", re.I)
+_DOCUMENT_RE = re.compile(
+    r"\b(?P<label>(?:dow[oó]d(?:u|em)?[ \t]+osobist(?:y|ego|ym)|"
+    r"(?:nr|numer)[ \t]+dowodu|paszport(?:u|em)?(?:[ \t]+dyplomatyczn(?:y|ego|ym))?)"
+    r"[ \t]*(?:(?:seria[ \t]+i[ \t]+numer|serii|seria|numer|nr)\.?[ \t]*)?"
+    r"[:=-]?[ \t]*)"
+    r"(?P<number>[A-Z]{3}[ \t-]?[0-9OIl]{6}|[A-Z]{2}[ \t-]?[0-9OIl]{7}|[A-Z][ \t-]?[0-9]{6,9}|[0-9]{4,12})\b", re.I,
+)
+_LABELLED_ID_RE = re.compile(
+    r"\b(?P<label>(?P<kind>PESEL|NIP|REGON)\b"
+    r"(?:[ \t]+(?:Gminy|Powiatu|Miasta|firmy)(?:[ \t]+[^\W\d_][^\W\d_-]*){0,4})?[ \t]{0,8}"
+    r"(?:(?:nr\.?|numer)[ \t]{0,8})?[:=.\-]?[ \t]{0,8}(?:\r?\n[ \t]{0,8})?)"
+    r"(?P<number>(?:PL[ \t]*)?(?:[0-9OIl]{9,14}|\d(?:[ \t-]?\d){8,13}))"
+    r"(?!\w|[ \t-]*\d)", re.I,
+)
 _REGON9_RE = re.compile(r"\b\d{9}\b")
+_ID_LABEL_END = r"[ \t]{0,8}(?:(?:nr\.?|numer)[ \t]{0,8})?[:=.\-]?[ \t]{0,8}(?:\r?\n[ \t]{0,8})?\Z"
+_NIP_LABEL_RE = re.compile(r"\bNIP\b" + _ID_LABEL_END, re.I)
+_REGON_LABEL_RE = re.compile(r"\bREGON\b" + _ID_LABEL_END, re.I)
+_KRS_RE = re.compile(r"\b\d{6,10}(?!\w|[ \t-]*\d)")
+_KRS_LABEL_RE = re.compile(r"\bKRS\b" + _ID_LABEL_END, re.I)
 # Separators are short and local: one newline *or* a few punct/spaces.
 # Letters and blank lines break the match so body text is not swallowed.
-_SEP = r"(?:[ \t.\-()\u2013\u2014]{0,3}|\n)"
+_SEP = r"(?:[ \t./\-()\u2013\u2014]{0,3}|\n)"
+_VANITY_PHONE_RE = re.compile(
+    r"(?<!\w)\+1[ \t-]+\d{3}[ \t-]+(?:\d{3}-[A-Z]{4}|[A-Z]{7})"
+    r"(?:[ \t]+\(\d{4,7}\))?(?!\w)")
 _PHONE_RE = re.compile(
-    r"(?<!\d)(?:(?:\+|00)[ \t]*48" + _SEP + r")?"
-    r"(?:\(0?\d{2,3}\)" + _SEP + r")?"
-    r"\d(?:" + _SEP + r"\d){6,14}"
+    _VANITY_PHONE_RE.pattern + r"|(?:(?<!\w)|(?<=telefon)|(?<=tel)|(?<=faks)|(?<=fax))(?:\(?\+[ \t]*)?"
+    r"(?:\((?:0|0?\d{2,4}(?:-\d{1,2})?)\)" + _SEP + r")?"
+    r"\d(?:" + _SEP + r"\d){4,}(?!\w)", re.I,
+)
+_SHORT_PHONE_LABEL_RE = re.compile(
+    r"(?:\b(?:tel(?:efon\w*)?(?:(?:\.[ \t]*|[ \t]+)(?:kom[oó]rk\w*|lokaln\w*|stacjonarn\w*))?|fax|faks(?:em)?|phone|"
+    r"toll[ -]free|numer[ \t]+bezpłatny)|[☎☏📞📱])[.: \t/]{0,8}\Z|"
+    r"\binfolini[^\W\d_]*[^\d\n]{0,80}:[ \t]*\Z", re.I)
+_PHONE_LABEL_RE = re.compile(
+    r"\b(?:tel(?:efon[^\W\d_]*)?|fax|faks(?:em)?|kom(?:[oó]rk[^\W\d_]*)?|gsm|"
+    r"infolini[^\W\d_]*|(?:za)?dzwo[ńn][^\W\d_]*|Blikiem|"
+    r"lini[ęaąie][ \t]+wsparcia)(?![^\W\d_])|"
+    r"\bkontakt(?=tel[.:])|[☎☏📞📱]", re.I,
+)
+_PHONE_BREAK_RE = re.compile(
+    r"\n|\.[ \t]+(?=\d)|[ \t]+(?=\(?(?:[01]?\d|2[0-3])[.:][0-5]\d"
+    r"|\d{1,2}[.)][ \t]+\d{1,2}[./]\d{1,2}[./](?:19|20)\d{2})")
+_PHONE_EXTENSION_RE = re.compile(r"(?:(?:[ \t]+,?[ \t]*|,[ \t]*)wew(?:n(?:ętrzny)?)?\.?[ \t]*\d{1,5}|[ \t]+do[ \t]+\d{1,3}(?=[ \t]*(?:[.;,](?!\d)|\r?\n|\Z)))(?!\w|[ \t]*\d)", re.I)
+_SERVICE_PHONE_RE = re.compile(r"(?<![\w+])[1-9]\d{2}(?![\w\d]|[ \t./()-]*\d)")
+_SERVICE_PHONE_LABEL_RE = re.compile(
+    r"(?:\b(?:tel(?:efon\w*)?|phone)[.: \t]{0,8}(?:alarmow\w*[.: \t]{0,8})?|"
+    r"\b(?:numer[ \t]+)?bezpłatny[.: \t]{0,8}|"
+    r"\b(?:bezpłatny[ \t]+)?numer[ \t]+alarmowy[.: \t]{0,8}|"
+    r"(?:^|\n)[ \t]*(?:Straż pożarna|Policja|Pogotowie|Ratunek|Lekarz pogotowia ratunkowego)"
+    r"(?:[ \t]+\([^()\n]{1,60}\))?[ \t]*:[ \t]*)"
+    r"(?:[1-9]\d{2}[ \t]*(?:[,;]|i|lub|oraz)[ \t]*)*\Z", re.I)
+_OTHER_NUMBER_LABEL_RE = re.compile(r"\b(?:NIP|REGON|PESEL|KRS|ISBN|kod)\b[^\d\n]{0,20}\Z", re.I)
+_PHONE_LIST_HEADING_RE = re.compile(
+    r"[ \t]*(?:numery[ \t]+kontaktowe|telefony(?:[ \t]+(?:kontaktowe|zaufania))?|fax|faks|zapisz[ \t]+się|"
+    r"(?:[^.!?\n]{0,40}\?[ \t]*)?(?:za)?dzwoń!?)"
+    r"(?:[ \t]*\([^()\n]{1,80}\))?[ \t]*:?[ \t]*", re.I)
+_CONTACT_INTRO_RE = re.compile(
+    r"\b(?:kontakt\b|zapisy\b|zapisz[ \t]+się\b|rejestracja\b)"
+    r"(?:nr\.|[^\n.!?;]){0,75}\Z", re.I)
+_PHONE_HEADING_RE = re.compile(
+    r"(?<!\[)\b(?:tel(?:efon[^\W\d_]*)?\b|kontakt\b|zapisy\b|zapisz[ \t]+się\b|"
+    r"(?:za)?dzwo[ńn][^\W\d_]*\b|(?:pod|na)[ \t]+numer(?:em)?)"
+    r"(?:tj\.|nr\.|[^\d\n.!?;\[\]]){0,75}:?[ \t]*(?:\n[ \t]*){1,4}\Z", re.I)
+_CONTACT_EXCLUDE_RE = re.compile(r"\b(?:spraw\w*|kod\w*|kwot\w*|statystyk\w*|taryf\w*)\b", re.I)
+_PHONE_LINE_RE = re.compile(r"(?<!\w)\d{2,3}(?:[ \t-]\d{2,4}){2,3}(?!\w)")
+_STAFF_ROLE_RE = re.compile(
+    r"\b(?:inspektor|referent|koordynator|psycholog|księgowość|księgowy|księgowa|"
+    r"pracownicy[ \t]+socjalni|łowczy|podłowczy)\b", re.I)
+
+
+def _phone_list_context(text: str, start: int) -> bool:
+    # ponytail: 2,000-character lookback and 400-character entry suffix; longer
+    # lists need repeated headings or a section parser. Never cross prose.
+    end = text.find('\n', start, start + 401)
+    if end < 0 and len(text) > start + 400:
+        return False
+    lines = text[max(0, start - 2000):end if end >= 0 else len(text)].splitlines()
+    if start > 2000:
+        lines = lines[1:]  # A truncated line cannot establish a heading.
+    for i, line in enumerate(reversed(lines)):
+        if _PHONE_LIST_HEADING_RE.fullmatch(line):
+            return i > 0
+        if not line.strip():
+            continue
+        phone = _PHONE_RE.search(line)
+        if not phone or not _phone_ok(phone[0], short=True) or _is_amount(line, *phone.span()):
+            return False
+        if i == 0 and phone.start() != start - (text.rfind('\n', 0, start) + 1):
+            return False  # Numbers in an entry's description are not list items.
+        before, after = line[:phone.start()].strip(), line[phone.end():].strip()
+        if _OTHER_NUMBER_LABEL_RE.search(before):
+            return False
+        # Either "City: number" or "number – helpline description". Bare
+        # numeric rows are ambiguous even below an earlier contact heading.
+        named = re.fullmatch(r"[^\W\d_][^\d\n:;]{0,79}[:–—-]", before)
+        described = before in ('', '•', '-', '*') and re.match(r"[–—-][ \t]+[^\W\d_]", after)
+        dialling = re.fullmatch(r"[-•*]?[ \t]*(?:dzwoniąc[ \t]+)?z[ \t]+[^\W\d_][^\d\n:;.!?]{0,100}", before, re.I)
+        if not (((named or dialling) and after in ('', ',', ';', '.')) or described):
+            return False
+    return False
+
+
+def _phone_context(text: str, start: int, raw: str) -> bool:
+    # A previous redaction is a boundary, not a fresh "Telefon" cue. Include
+    # one marker's extra width so the 75-character window cannot bisect it.
+    before = re.split(r"\n[ \t]*\n|\[Telefon\]|\[PII\]",
+                      text[max(0, start - 75 - len(PHONE_TAG)):start])[-1][-75:]
+    if _OTHER_NUMBER_LABEL_RE.search(before):
+        return False
+    intro = _CONTACT_INTRO_RE.search(before)
+    if intro and not _CONTACT_EXCLUDE_RE.search(intro[0]):
+        return True
+    # A contact email must not erase an explicit contact label for the phone
+    # following it. Other redactions still form boundaries.
+    if re.search(r'\bkontakt[ \t]*:[ \t]*\[PII\][ \t,;]*\Z',
+                 text[max(0, start-75):start], re.I):
+        return True
+    lead = re.split(r'\[Telefon\]|\[PII\]', text[max(0, start-240):start])[-1]
+    # "Pod numerem" also introduces contract/case references. Require a
+    # communication cue when the number has no explicit telephone label.
+    number_contact = bool((_PHONE_LABEL_RE.search(lead) or re.search(
+        r'\b(?:informacj[^\W\d_]*|zgłosz[^\W\d_]*|zapis[^\W\d_]*|SMS(?:-a)?|połączeni[^\W\d_]*)\b', lead, re.I))
+        and not _CONTACT_EXCLUDE_RE.search(lead)
+        and not re.search(r'\b(?:umow|faktur|dokument)[^\W\d_]*\b', lead, re.I))
+    heading = _PHONE_HEADING_RE.search(text[max(0, start-160):start])
+    if (heading and not _CONTACT_EXCLUDE_RE.search(heading[0])
+            and (not re.match(r'(?:pod|na)\b', heading[0], re.I)
+                 or _PHONE_LABEL_RE.search(heading[0]) or number_contact)):
+        return True
+    if (number_contact and re.search(r'\b(?:pod[ \t]+numerem|na[ \t]+numer)[ \t]*:?[ \t]*\Z', before, re.I)):
+        return True
+    if re.search(r'\bтелефону[ \t]*:[ \t]*\Z', before, re.I):
+        return True
+    # An international phone may precede a labelled fax in the same contact list.
+    # Keep this cue adjacent: arbitrary later contact prose is not evidence.
+    after = text[start + len(raw):start + len(raw) + 40]
+    if re.match(r'[ \t]*[–—-][ \t]+telefon\b', after, re.I):
+        return True
+    if (re.match(r"\(?(?:\+|00)", raw)
+            and re.match(r"[ \t]*[,;][ \t]*(?:fax|faks(?:em)?)[.: \t]*(?=[+(0-9])", after, re.I)):
+        return True
+    # A foreign-looking +number can also be an increment in a financial table.
+    return bool(re.match(r"\(?(?:\+|00)[ \t]*48|\+\d{1,3}[ \t]+\(0\)", raw)
+                or _PHONE_LABEL_RE.search(before))
+
+
+def _directory_context(text: str, start: int, end: int) -> bool:
+    """Recognize phones in bounded staff and named-address contact records."""
+    raw = text[start:end]
+    foreign = raw.startswith('+') and _phone_ok(raw)
+    if not foreign and (not _pl_national_ok(_digits(raw)) or not re.search(r'[ \t-]', raw)):
+        return False
+    # ponytail: local 1,600-character directory evidence; longer isolated rows
+    # need preserved upstream table structure, not an unbounded document cue.
+    left, right = max(0, start-800), min(len(text), end+800)
+    nearby = text[left:right]
+    line_start, line_end = text.rfind('\n', 0, start)+1, text.find('\n', end)
+    line_end = len(text) if line_end < 0 else line_end
+    before, after = text[line_start:start], text[end:line_end]
+    if _CONTACT_EXCLUDE_RE.search(before) or _OTHER_NUMBER_LABEL_RE.search(before):
+        return False
+    if foreign:
+        # A comma-delimited name/address entry needs a labelled phone nearby;
+        # a +number alone could be an increment in a financial table.
+        address = re.search(r'(?:^|,)[ \t]*[^\W\d_][^,\n]{1,120},'
+                            r'[^\n]{0,160}\d[^\n]{0,80},[ \t]*\Z', before)
+        return bool(address and any(
+            _SHORT_PHONE_LABEL_RE.search(nearby[max(0,m.start()-80):m.start()])
+            for m in _PHONE_RE.finditer(nearby) if m[0].startswith('+') and _phone_ok(m[0])))
+    standalone = not before.strip() and not after.strip()
+    lead = text[max(0, start-400):start]
+    if (standalone and re.search(r'\b(?:infolini[^\W\d_]*|helpline)\b', lead, re.I)
+            and not _CONTACT_EXCLUDE_RE.search(lead)):
+        return True
+    if (standalone and re.search(r'\bnr\.?[ \t]+telefonu\b', nearby, re.I)
+            and re.search(r'\b(?:pok[oó]j|pokoju)\b', nearby, re.I)
+            and re.search(r'\bnazwisko\b', nearby, re.I)):
+        return True
+    # Email/name/role records and phone-led service directories repeat formatted
+    # values. A lone staff title beside a number is insufficient evidence.
+    phones = [m for m in _PHONE_LINE_RE.finditer(nearby)
+              if _pl_national_ok(_digits(m[0])) and not _is_amount(nearby, *m.span())]
+    roles = list(_STAFF_ROLE_RE.finditer(nearby))
+    if len(phones) < 2 or len(roles) < 2:
+        return False
+    return bool((re.search(r'\[PII\]', before[-100:] + after[:100]) and
+                 re.search(r'[^\W\d_]', before[-100:]))
+                or (not before.strip() and re.match(r'[ \t]+[^\W\d_]', after))
+                or _STAFF_ROLE_RE.search(before[-100:]))
+
+
+# Amounts can look like phones or checksum-valid national IDs. Keep the
+# currency adjacent to the number, allowing a decimal, multiplier and line wrap.
+_MONEY_GAP = r"[ \t]*(?:\n[ \t]*)?"
+_CURRENCY = r"(?:PLN|z[łl](?:ot(?:ych|ego|emu|ymi|ym|y|e))?|EUR(?:O)?|USD|GBP|CHF)\b|[%€$£]"
+_MONEY_AFTER_RE = re.compile(
+    r"(?:[,.][0-9]+)?" + _MONEY_GAP
+    + r"(?:(?:tys\.?|mln|mld|bln)\b\.?" + _MONEY_GAP + r")?"
+    + r"(?:" + _CURRENCY + r")", re.I,
 )
+_MONEY_BEFORE_RE = re.compile(r"(?:\b(?:PLN|EUR|USD|GBP|CHF)|[€$£])" + _MONEY_GAP + r"$", re.I)
+
+
+def _is_amount(text: str, start: int, end: int) -> bool:
+    return bool(_MONEY_AFTER_RE.match(text, end) or _MONEY_BEFORE_RE.search(text[max(0, start - 32):start]))
 
 
 def _digits(s: str) -> str:
@@ -86,32 +336,107 @@ def _regon_ok(d: str) -> bool:
 
 
 def _iban_ok(raw: str) -> bool:
+    # Do not assemble an alphanumeric account from neighbouring prose words.
+    # Compact and ordinary four-character printed groups remain supported.
+    groups = re.split(r'[ \t-]+', raw)
+    if len(groups) > 1 and any(re.search(r'[A-Za-z]{5}', group) for group in groups):
+        return False
     compact = re.sub(r"[\s-]+", "", raw).upper()
     if compact.isdigit() and len(compact) == 26:
         compact = "PL" + compact
-    if not re.fullmatch(r"PL\d{26}", compact):
+    if not re.fullmatch(r"[A-Z]{2}[0-9]{2}[A-Z0-9]+", compact):
+        return False
+    if len(compact) != _IBAN_LENGTHS.get(compact[:2]) or not 2 <= int(compact[2:4]) <= 98:
+        return False
+    if compact.startswith("PL") and not compact[2:].isdigit():
         return False
     rearranged = compact[4:] + compact[:4]
     nums = "".join(str(ord(c) - 55) if c.isalpha() else c for c in rearranged)
     return int(nums) % 97 == 1
 
 
+def _tag(start, end, tag):
+    return tag
+
+
+def _replace_epuap(text: str, *, mask=_tag) -> tuple[str, int]:
+    last_end, count = None, 0
+
+    def replace(m):
+        nonlocal last_end, count
+        labelled = _EPUAP_LABEL_RE.search(text, max(0, m.start()-64), m.start())
+        continued = last_end is not None and re.fullmatch(r'[ \t]*[;,][ \t]*|[ \t]+(?:lub|albo|i|oraz)[ \t]+', text[last_end:m.start()], re.I)
+        if not labelled and not continued:
+            return m[0]
+        last_end = m.end()
+        count += 1
+        return mask(m.start(), m.end(), PII_TAG)
+
+    out = _EPUAP_RE.sub(replace, text)
+    return out, count
+
+
+def _replace_documents(text: str, *, mask=_tag) -> tuple[str, int]:
+    n = 0
+
+    def replace(m):
+        nonlocal n
+        number = re.sub(r"[ \t-]", "", m["number"]).upper()
+        passport = m["label"].lower().startswith("paszport")
+        if passport:
+            short_diplomatic = ('dyplomatyczn' in m['label'].lower()
+                                and re.search(r'\b(?:nr|numer)\b', m['label'], re.I)
+                                and re.fullmatch(r'\d{4,5}', number))
+            if not short_diplomatic and not re.fullmatch(r"[A-Z]{2}[0-9OIL]{7}|[A-Z][0-9]{6,9}|[0-9]{6,12}", number):
+                return m[0]
+        elif not re.fullmatch(r"[A-Z]{3}[0-9OIL]{6}", number):
+            return m[0]
+        n += 1
+        return m["label"] + mask(m.start('number'), m.end('number'), PII_TAG)
+
+    # Passport detection is label/format based; no MRZ check digit is present here.
+    return _DOCUMENT_RE.sub(replace, text), n
+
+
 def _pl_national_ok(d: str) -> bool:
     return len(d) == 9 and d.isdigit() and d[:2] in _PL_PREFIX
 
 
-def _phone_ok(raw: str) -> bool:
+def _phone_ok(raw: str, short: bool = False) -> bool:
     s = raw.strip()
+    if _VANITY_PHONE_RE.fullmatch(s):
+        return short
+    if s.startswith('/') or s.endswith('/'):
+        return False
+    s = re.sub(r'^\(\+', '+', s)
+    s = re.sub(r'^\(00\)[ \t]*', '00', s)
     if re.fullmatch(r"\d{4}[-./]\d{2}[-./]\d{2}", s):
         return False
+    if re.fullmatch(r'\(?(?:[01]?\d|2[0-3])[.:][0-5]\d[ \t]*[–—-][ \t]*(?:[01]?\d|2[0-3])[.:][0-5]\d\)?', s):
+        return False
     if re.fullmatch(r"\d{2}-\d{3}", s):  # postal code
         return False
     # Ministry / court file numbers: BPRM.4820.2.3.2020, LUB-OMK.601.1.2024.3
-    if s.count(".") >= 3 or (s.count(".") >= 1 and re.search(r"20\d{2}", s)):
+    if s.count(".") >= 3 or (s.count(".") >= 1 and re.search(r"(?<!\d)20\d{2}(?!\d)", s)):
         return False
-    if re.search(r"\d{1,2}[-./]\d{1,2}[-./](?:19|20)\d{2}", s):
+    if re.search(r"(?<!\d)\d{1,2}[-./]\d{1,2}[-./](?:19|20)\d{2}(?!\d)", s):
         return False
     d = _digits(raw)
+    if short and re.fullmatch(r'[2-9]\d{2}-[2-9]\d{2}-\d{4}', s):
+        return True
+    if short and s.startswith('(0)'):
+        return 7 <= len(d) <= 12
+    # ponytail: label + shape + length, not a country numbering-plan validator.
+    if short and re.match(r'^\(0?\d{2,4}(?:-\d{1,2})?\)', s):
+        return 8 <= len(d) <= 15
+    if s.startswith(('+', '00')):
+        international = _digits(s.replace('(0)', ''))
+        if s.startswith('00'):
+            international = international[2:]
+        if not international.startswith('48'):
+            # ponytail: explicit prefix + length, not a global numbering-plan
+            # validator. Add country metadata if review finds false positives.
+            return (7 if '(0)' in s else 8) <= len(international) <= 15 and international[0] != '0'
     if d.startswith("00"):
         d = d[2:]
     if d.startswith("48") and len(d) >= 11:
@@ -122,59 +447,231 @@ def _phone_ok(raw: str) -> bool:
     if d.startswith("0") and len(d) == 11 and d[:2] in {"01", "02", "07"}:
         return True
     if d.startswith("0") and len(d) >= 10:
-        return _pl_national_ok(d.lstrip("0"))
-    return _pl_national_ok(d)
+        return _pl_national_ok(d.lstrip("0")) or (short and len(d) <= 12)
+    return (_pl_national_ok(d)
+            or (short and 5 <= len(d) <= 8 and d[0] != '0')
+            or (short and 9 <= len(d) <= 12 and bool(re.fullmatch(r'\d{2,4}(?:[ \t-]\d{2,4}){2,3}', s)))
+            or (short and 9 <= len(d) <= 12 and bool(re.fullmatch(r'\d{2,4}\.\d{6,8}', s)))
+            or (short and 9 <= len(d) <= 12 and d.startswith('0')))
 
 
-def _replace_checked(text: str, pattern: re.Pattern, tag: str, ok) -> tuple[str, int]:
+def _replace_checked(text: str, pattern: re.Pattern, tag: str, ok,
+                     label: re.Pattern | None = None, *, mask=_tag) -> tuple[str, int]:
     n = 0
 
     def _sub(m):
         nonlocal n
-        if not ok(m.group(0)):
+        if label is not None and not label.search(text, max(0, m.start() - 64), m.start()):
+            return m.group(0)
+        if pattern is _PESEL_RE and re.search(r'[/?&][^\s]*\Z', text[max(0, m.start()-500):m.start()]):
+            return m.group(0)  # Bare URL path/query digits are not personal identifiers.
+        if not ok(m.group(0)) or (pattern not in (_EMAIL_RE, _EMAIL_WRAP_RE, _EMAIL_FRAGMENT_RE)
+                                 and _is_amount(text, m.start(), m.end())):
             return m.group(0)
         n += 1
-        return tag
+        return mask(m.start(), m.end(), tag)
 
     return pattern.sub(_sub, text), n
 
 
-def _replace_phones(text: str) -> tuple[str, int]:
+def _replace_phones(text: str, *, mask=_tag) -> tuple[str, int]:
     n = 0
     out = []
     pos = 0
+    last_phone_end = None
     while True:
         m = _PHONE_RE.search(text, pos)
         if not m:
             out.append(text[pos:])
             break
-        if _phone_ok(m.group(0)):
-            out.append(text[pos:m.start()])
-            out.append(PHONE_TAG)
-            n += 1
-            pos = m.end()
-        else:
-            out.append(text[pos:m.start() + 1])
-            pos = m.start() + 1
+        raw = m[0]
+        end = m.end()
+        replacement = raw
+        line_end = text.find('\n', m.start(), end)
+        if line_end >= 0 and re.fullmatch(r'\d{1,3}', text[m.start():line_end]):
+            next_end = text.find('\n', line_end+1, end)
+            if _directory_context(text, line_end+1, next_end if next_end >= 0 else end):
+                # A flattened table's room cell is not a phone country prefix.
+                out.append(text[pos:line_end+1])
+                pos = line_end+1
+                continue
+        short = bool(_SHORT_PHONE_LABEL_RE.search(text[max(0, m.start()-100):m.start()]))
+        short = short or (re.fullmatch(r'116[ \t]?\d{3}', raw)
+                          and _phone_context(text, m.start(), raw))
+        short = short or _phone_list_context(text, m.start())
+        # A bare five-digit continuation followed by a place/name can be a
+        # postal address. It needs its own phone label to override that ambiguity.
+        postal = re.fullmatch(r'\d{5}', raw) and re.match(r'[ \t]+[^\W\d_]', text[end:])
+        if (last_phone_end is not None and not postal
+                and re.fullmatch(r"[ \t\n,;]{1,12}|[ \t]+(?:lub|albo)[ \t]+", text[last_phone_end:m.start()], re.I)):
+            short = True
+        if (last_phone_end is not None
+                and re.fullmatch(r'(?:[ \t]+(?:w sprawie\b|\((?:w godzinach|dostępny)\b)'
+                                 r'|[ \t]*[–—-][ \t]+)[^\d\n.!?]{1,200}\n[ \t\n]{0,8}',
+                                 text[last_phone_end:m.start()], re.I)
+                and _pl_national_ok(_digits(raw))):
+            short = True
+        if (short or _phone_context(text, m.start(), raw)
+                or _directory_context(text, m.start(), line_end if line_end >= 0 else end)):
+            if (_is_amount(text, m.start(), end)
+                    and re.fullmatch(r'\d{1,3}(?:\.[ \t]*\d{3})+', raw)):
+                out.extend((text[pos:m.start()], raw))
+                pos = end
+                continue
+            # Stop before a new line or opening hours, but only after a complete
+            # phone. Look past the greedy match's last digit to recognize HH:MM.
+            for gap in _PHONE_BREAK_RE.finditer(text, m.start(), end + 6):
+                if gap.start() >= end:
+                    break
+                # Foreign lengths vary: a valid-looking prefix may still be an
+                # incomplete wrapped number. Only a section marker ends it.
+                if (raw.startswith(('+', '00')) and not re.match(r'(?:\+|00)[ \t]*48', raw)
+                        and gap[0] == '\n'
+                        and not re.match(r'\d{1,2}[.)](?!\d)', text[gap.end():])):
+                    continue
+                prefix = text[m.start():gap.start()].rstrip(". \t")
+                if _phone_ok(prefix) and not _is_amount(text, m.start(), gap.start()):
+                    end = m.start() + len(prefix)
+                    raw = prefix
+                    replacement = raw
+                    break
+            if _is_amount(text, m.start(), end):
+                out.extend((text[pos:m.start()], raw))
+                pos = end
+                continue
+            # A suffix range repeats the final extension digits, not a second
+            # complete phone. Only accept it after a valid full base number.
+            extension = re.fullmatch(r"(.+?)[/-](\d{1,3})", raw)
+            parenthesized_extension = re.fullmatch(r'(.+?)[ \t]+\(\d{1,5}', raw)
+            if not (text[end:end+1] == ')' and parenthesized_extension
+                    and _phone_ok(parenthesized_extension[1])):
+                parenthesized_extension = None
+            pair = re.fullmatch(r"(.+?)[ \t]+[–—-][ \t]+(.+)", raw)
+            shared = re.match(r"\(\d{2,4}\)[ \t]*", pair[1]) if pair else None
+            full_range = (pair and _phone_ok(pair[1], short)
+                          and _phone_ok((shared[0] if shared else '') + pair[2], short))
+            if (_phone_ok(raw, short) or (extension and _phone_ok(extension[1]))
+                    or parenthesized_extension or full_range):
+                if raw.count('(') > raw.count(')') and text[end:end+1] == ')':
+                    end += 1
+                suffix = _PHONE_EXTENSION_RE.match(text, end)
+                if suffix and not _is_amount(text, suffix.start(), suffix.end()):
+                    end = suffix.end()
+                start = m.start()
+                # Parentheses enclosing prose are punctuation, not phone syntax.
+                if raw.startswith('(+') and raw.count('(') > raw.count(')') and text[end-1:end] != ')':
+                    start += 1
+                replacement = text[m.start():start] + mask(start, end, PHONE_TAG)
+                n += 1
+            # ponytail: split only pairs (<=22 digits); longer lists need label
+            # context to distinguish them from accounts. Never redact ID tails.
+            elif 18 <= len(_digits(raw)) <= 22 and "." not in raw:
+                for gap in re.finditer(r"[ \t]*/[ \t]*|[ \t\n]+", raw):
+                    if _phone_ok(raw[:gap.start()]) and _phone_ok(raw[gap.end():]):
+                        replacement = (mask(m.start(), m.start()+gap.start(), PHONE_TAG)
+                                       + gap[0] + mask(m.start()+gap.end(), end, PHONE_TAG))
+                        n += 2
+                        break
+        out.extend((text[pos:m.start()], replacement))
+        if replacement != raw:
+            last_phone_end = end
+        pos = end
     return "".join(out), n
 
 
-def scrub_pii(text: str) -> tuple[str, dict[str, int]]:
-    """Return (scrubbed_text, per-kind replacement counts). Idempotent."""
+def _replace_extensions(text: str, *, mask=_tag) -> tuple[str, int]:
+    count = 0
+
+    def replace(m):
+        nonlocal count
+        before = text[max(0, m.start()-500):m.start()]
+        # Only a telephone followed by extension/name entries establishes scope.
+        heading = re.search(r'\btel(?:efon)?[.: \t]*\[Telefon\]'
+                            r'(?P<entries>(?:\s*wewn?\.?[ \t]+\d{1,5}[ \t]+[^\d\n]+)*\s*)\Z', before, re.I)
+        if not heading or _is_amount(text, m.start('number'), m.end('number')):
+            return m[0]
+        count += 1
+        return m['label'] + mask(m.start('number'), m.end('number'), PHONE_TAG)
+
+    output = re.sub(r'(?P<label>(?:^|\n)[ \t]*wewn?\.?[ \t]+)(?P<number>\d{1,5})(?!\w)',
+                    replace, text, flags=re.I)
+    return output, count
+
+
+def scrub_pii(text: str, *, spans: list | None = None) -> tuple[str, dict[str, int]]:
+    """Return (scrubbed_text, counts); optionally append exact original spans.
+
+    Offset tracking is opt-in; corpus ingestion keeps its existing return type
+    and does not allocate a character map. Unicode offsets count code points.
+    """
     counts = {k: 0 for k in COUNTS}
     if not text:
         return text, counts
+    original = text
+    text = text.translate(_SPACES)  # One character per character: offsets survive.
+    offsets = list(range(len(text))) if spans is not None else None
+    edits = []
+
+    def mask(start, end, tag):
+        if spans is not None:
+            a, b = offsets[start], offsets[end-1] + 1
+            spans.append(dict(start=a, end=b, text=original[a:b],
+                              label='phone' if tag == PHONE_TAG else 'pii'))
+            edits.append((start, end, tag))
+        return tag
+
+    def apply(replacer, *args):
+        nonlocal text
+        text, result = replacer(text, *args, mask=mask)
+        # Each replacement pass uses one coordinate system. Apply its edits
+        # backwards only after all regex callbacks have finished.
+        for start, end, tag in reversed(edits):
+            offsets[start:end] = [offsets[start]] * len(tag)
+        edits.clear()
+        return result
 
     # Longest / most specific first so a 26-digit account is not sliced
     # into REGON / PESEL / NIP / phone. Checksums live in the replace callback.
-    text, counts["account"] = _replace_checked(text, _ACCOUNT_RE, PII_TAG, _iban_ok)
-    text, n14 = _replace_checked(text, _REGON14_RE, PII_TAG, _regon_ok)
-    text, n9 = _replace_checked(text, _REGON9_RE, PII_TAG, _regon_ok)
-    counts["regon"] = n14 + n9
-    text, counts["pesel"] = _replace_checked(text, _PESEL_RE, PII_TAG, _pesel_ok)
-    text, n_dash = _replace_checked(text, _NIP_DASH_RE, PII_TAG, lambda s: _nip_ok(_digits(s)))
-    text, n_plain = _replace_checked(text, _NIP_RE, PII_TAG, _nip_ok)
-    counts["nip"] = n_dash + n_plain
-    text, counts["email"] = _replace_checked(text, _EMAIL_RE, PII_TAG, lambda _: True)
-    text, counts["phone"] = _replace_phones(text)
+    def pins(value, *, mask):
+        def replace(m):
+            if _is_amount(value, m.start('number'), m.end('number')):
+                return m[0]
+            counts['pin'] += 1
+            return m['label'] + mask(m.start('number'), m.end('number'), PII_TAG)
+        return _PIN_RE.sub(replace, value), None
+    apply(pins)
+    foreign = apply(_replace_checked, _IBAN_RE, PII_TAG, _iban_ok)
+    bare = apply(_replace_checked, _ACCOUNT_RE, PII_TAG, _iban_ok)
+    counts["account"] = foreign + bare
+    counts['electronic_address'] = apply(_replace_checked, _EDELIVERY_RE, PII_TAG, lambda _: True)
+    counts['electronic_address'] += apply(_replace_epuap)
+    counts['krs'] = apply(_replace_checked, _KRS_RE, PII_TAG, lambda _: True, _KRS_LABEL_RE)
+    counts["document"] = apply(_replace_documents)
+    def labelled_ids(value, *, mask):
+        def replace(m):
+            if len(_digits(m['number'])) < 7 or _is_amount(value, m.start('number'), m.end()):
+                return m[0]
+            counts[m['kind'].lower()] += 1
+            return m['label'] + mask(m.start('number'), m.end('number'), PII_TAG)
+        return _LABELLED_ID_RE.sub(replace, value), None
+    apply(labelled_ids)
+    n14 = apply(_replace_checked, _REGON14_RE, PII_TAG, _regon_ok, _REGON_LABEL_RE)
+    n9 = apply(_replace_checked, _REGON9_RE, PII_TAG, _regon_ok, _REGON_LABEL_RE)
+    counts["regon"] += n14 + n9
+    n_dash = apply(_replace_checked, _NIP_DASH_RE, PII_TAG, lambda s: _nip_ok(_digits(s)), _NIP_LABEL_RE)
+    n_plain = apply(_replace_checked, _NIP_RE, PII_TAG, lambda s: _nip_ok(_digits(s)), _NIP_LABEL_RE)
+    counts["nip"] += n_dash + n_plain
+    counts["email"] = apply(_replace_checked, _EMAIL_WRAP_RE, PII_TAG,
+        lambda s: not _EMAIL_RE.fullmatch(s.splitlines()[0].rstrip('. \t')))
+    counts["email"] += apply(_replace_checked, _EMAIL_RE, PII_TAG, lambda _: True)
+    counts["email"] += apply(_replace_checked, _EMAIL_FRAGMENT_RE, PII_TAG,
+                             lambda _: True, _EMAIL_LABEL_RE)
+    counts["phone"] = apply(_replace_phones)
+    counts["phone"] += apply(_replace_checked, _SERVICE_PHONE_RE, PHONE_TAG,
+                             lambda _: True, _SERVICE_PHONE_LABEL_RE)
+    counts['phone'] += apply(_replace_extensions)
+    # Contact context takes precedence over coincidental PESEL checksums in
+    # foreign phone numbers; explicitly labelled identifiers were handled first.
+    bare_pesel = apply(_replace_checked, _PESEL_RE, PII_TAG, _pesel_ok)
+    counts['pesel'] += bare_pesel
     return text, counts

src/test_pii_mixed_regressions.py

@@ -0,0 +1,49 @@
+"""Synthetic contact-format regressions; human exports are never test inputs."""
+import json
+from pathlib import Path
+import unittest
+
+from scrub_pii import scrub_pii
+
+
+class MixedRegressionTest(unittest.TestCase):
+    pass
+
+
+def regression(case):
+    def check(self):
+        text, spans = case['text'], []
+        scrub_pii(text, spans=spans)
+        for wanted in case['mask']:
+            self.assertEqual(text[wanted['start']:wanted['end']], wanted['text'])
+            covered = {i for span in spans if span['label'] == wanted['label']
+                       for i in range(span['start'], span['end'])}
+            required = {i for i in range(wanted['start'], wanted['end']) if not text[i].isspace()}
+            self.assertFalse(required-covered, case['name'])
+            overlapping = {i for span in spans
+                           if required & set(range(span['start'], span['end']))
+                           for i in range(span['start'], span['end']) if not text[i].isspace()}
+            self.assertFalse(overlapping-set(range(wanted['start'], wanted['end'])), case['name'])
+        covered = {i for span in spans for i in range(span['start'], span['end'])}
+        for wanted in case['preserve']:
+            self.assertEqual(text[wanted['start']:wanted['end']], wanted['text'])
+            self.assertFalse(covered & set(range(wanted['start'], wanted['end'])), case['name'])
+    return check
+
+
+fixtures = [json.loads(Path(__file__).with_name(name).read_text()) for name in
+            ('pii_mixed_regression_cases.json', 'pii_wikivoyage_regression_cases.json')]
+assert all(fixture['synthetic'] is True for fixture in fixtures)
+cases = [case for fixture in fixtures for case in fixture['cases']]
+assert len({case['name'] for case in cases}) == len(cases)
+for case in cases:
+    assert set(case) == {'name', 'text', 'mask', 'preserve'}
+    assert case['mask'] or case['preserve']
+    for target in case['mask'] + case['preserve']:
+        assert 0 <= target['start'] < target['end'] <= len(case['text'])
+        assert case['text'][target['start']:target['end']] == target['text']
+    setattr(MixedRegressionTest, 'test_'+case['name'], regression(case))
+
+
+if __name__ == '__main__':
+    unittest.main()

src/test_scrub_pii.py

@@ -7,7 +7,10 @@ sys.path.insert(0, str(Path(__file__).resolve().parent))
 
 from scrub_pii import scrub_pii
 
-# Checksum-valid fixtures (not live identifiers of private people).
+# Synthetic contact/identifier fixtures; no copied directory entries.
+# Email domains use example.com; emergency/service codes retain their semantics.
+# Numeric fixtures test syntax/checksums, not whether a number is assigned.
+# The IBAN cases use published example numbers.
 PESEL = "44051401458"
 NIP = "1234563218"
 REGON9 = "123456785"
@@ -16,6 +19,632 @@ IBAN = "PL61109010140000071219812874"
 
 
 class ScrubPiiTest(unittest.TestCase):
+    def test_email_spacing_on_both_sides_of_at(self):
+        for value in ('osoba @example.com', 'osoba @ example.com', 'osoba@ example.com',
+                      'osoba\t@\texample.com', 'osoba\u00a0@\u202fexample.com',
+                      'osoba @ example.\ncom'):
+            with self.subTest(value=value):
+                text, spans = 'E-mail: '+value+'.', []
+                out, counts = scrub_pii(text, spans=spans)
+                self.assertEqual(out, 'E-mail: [PII].')
+                self.assertEqual(counts['email'], 1)
+                self.assertEqual(spans, [dict(start=8, end=8+len(value), text=value, label='pii')])
+                self.assertEqual(scrub_pii(out), (out, dict.fromkeys(counts, 0)))
+        self.assertEqual(scrub_pii('E-mail: osoba @\n')[0], 'E-mail: [PII]\n')
+        for text in ('osoba\n@example.com', 'osoba    @example.com',
+                     'osoba @example..com', 'osoba @', 'systemd-fsck@.service'):
+            self.assertEqual(scrub_pii(text)[0], text)
+
+    def test_wikivoyage_repair_guards(self):
+        for label in ('Telefon komórkowy: ', 'tel.komórkowy: ', 'tel. komórkowy: '):
+            self.assertEqual(scrub_pii(label+'(53) 05 234567123')[0], label+'[Telefon]')
+        for text in ('PO Box 11155-3489', 'Telefon: 2026-09-08',
+                     'Fax:\n- z Polski 12 345 678 PLN',
+                     'Fax:\n- z Polski 0066 2 234 5613\n\nDane statystyczne\n12 345 678',
+                     'Tabela +86 351 2345613',
+                     'Hotel Przykład, ulica Testowa 16, +36 84 234 562 EUR',
+                     'Hotel Przykład, ulica Testowa 16, kod +36 84 234 562'):
+            with self.subTest(text=text):
+                expected = text.replace('0066 2 234 5613', '[Telefon]')
+                self.assertEqual(scrub_pii(text)[0], expected)
+
+    def test_phone_continuation_preserves_postal_address(self):
+        for text, expected in (
+            ('Ulica Testowa, 108, tel: 393 234 5671, 95131 Miasto.',
+             'Ulica Testowa, 108, tel: [Telefon], 95131 Miasto.'),
+            ('tel. +39 393 234 5671, 95131 Miasto.', 'tel. [Telefon], 95131 Miasto.'),
+            ('tel. 501 234 567, 12345', 'tel. [Telefon], [Telefon]'),
+            ('tel. 501 234 567, 123 456 sekretariat', 'tel. [Telefon], [Telefon] sekretariat'),
+            ('tel. 95131 Miasto', 'tel. [Telefon] Miasto'),
+        ):
+            with self.subTest(text=text):
+                self.assertEqual(scrub_pii(text)[0], expected)
+
+    def test_mixed_repair_boundaries(self):
+        for text, expected in (
+            ('tel. kwota 500. 100. 200. 300 PLN', 'tel. kwota 500. 100. 200. 300 PLN'),
+            ('tel. 501 234 567 do 29 marca', 'tel. [Telefon] do 29 marca'),
+            ('tel. 501 234 567 do 29.12.2026', 'tel. [Telefon] do 29.12.2026'),
+            ('a@example.com.\nNext.section', '[PII].\nNext.section'),
+            ('Nakład +27 (0)13 234-5612 EUR', 'Nakład +27 (0)13 234-5612 EUR'),
+            ('tel. 501 234 567. 123,00 zł', 'tel. [Telefon]. 123,00 zł'),
+            ('Faks: +33 1 23 45 67 12\n—\nD-60322\nFrankfurt',
+             'Faks: [Telefon]\n—\nD-60322\nFrankfurt'),
+            ('☏ +1 202 555-TEST (8378), +1 202 555-0142', '☏ [Telefon], [Telefon]'),
+            ('Telefony alarmowe: 997, 112\nDyżurny KPP: 68 123 45 67',
+             'Telefony alarmowe: [Telefon], [Telefon]\nDyżurny KPP: [Telefon]'),
+            ('Infolinię uruchomiono od 22-26.04.br.', 'Infolinię uruchomiono od 22-26.04.br.'),
+            ('Tel Aviv, s. 499-515.', 'Tel Aviv, s. 499-515.'),
+            ('równoważne zapisy modelu: 70-20-10', 'równoważne zapisy modelu: 70-20-10'),
+            ('Sprzęt teleinf. i telekom.\n24 965,3\n11 145,3\n13 693,5',
+             'Sprzęt teleinf. i telekom.\n24 965,3\n11 145,3\n13 693,5'),
+        ):
+            with self.subTest(text=text):
+                self.assertEqual(scrub_pii(text)[0], expected)
+
+    def test_labelled_email_fragment_at_line_end(self):
+        for text, expected in (
+            ('adres e-mail: j.kowalski@\n\nDalszy tekst.', 'adres e-mail: [PII]\n\nDalszy tekst.'),
+            ('EMAIL:łukasz@  \r\n', 'EMAIL:[PII]  \r\n'),
+            ('e-mail: osoba@', 'e-mail: [PII]'),
+            ('osoba@', 'osoba@'),
+            ('plik: systemd-fsck@.service', 'plik: systemd-fsck@.service'),
+            ('e-mail: osoba@example..com', 'e-mail: osoba@example..com'),
+            ('e-mail: osoba@ example.com', 'e-mail: [PII]'),
+        ):
+            with self.subTest(text=text):
+                spans = []
+                out, counts = scrub_pii(text, spans=spans)
+                self.assertEqual(out, expected)
+                self.assertEqual(counts['email'], int(out != text))
+                for span in reversed(spans):
+                    self.assertEqual(text[span['start']:span['end']], span['text'])
+                    text = text[:span['start']] + '[PII]' + text[span['end']:]
+                self.assertEqual(text, out)
+                self.assertEqual(scrub_pii(out), (out, dict.fromkeys(counts, 0)))
+
+    def test_reviewed_directory_contact_and_number_boundaries(self):
+        cases = [
+            ('Kontakt: Jan Kowalski: 501 234 567', 'Kontakt: Jan Kowalski: [Telefon]'),
+            ('Kontakt: a@example.com, (22) 123 45 67', 'Kontakt: [PII], [Telefon]'),
+            ('Zapisy do piątku 14 marca pod nr 41 234 56 71', 'Zapisy do piątku 14 marca pod nr [Telefon]'),
+            # Contact headings establish phone context across blank lines.
+            ('Zapisy pod numerem:\n\n501234567', 'Zapisy pod numerem:\n\n[Telefon]'),
+            ('Nr telefonu do kontaktu:\n\n13 2345671\n\n502234571',
+             'Nr telefonu do kontaktu:\n\n[Telefon]\n\n[Telefon]'),
+            ('Wszystkie sprawy należy kierować pod numer telefonu:\n\n18 23 45 671',
+             'Wszystkie sprawy należy kierować pod numer telefonu:\n\n[Telefon]'),
+            ('Telefon: 25 23 - 456 - 71- sekretariat\n\n25 23 - 456 - 71 wew. 2 - intendent',
+             'Telefon: [Telefon]- sekretariat\n\n[Telefon] - intendent'),
+            ('Zapisz się:\n\nJan Kowalski: 501 234 567\n\nAnna Nowak: 22 123 45 67',
+             'Zapisz się:\n\nJan Kowalski: [Telefon]\n\nAnna Nowak: [Telefon]'),
+            ('tel. 132345671/699234571', 'tel. [Telefon]/[Telefon]'),
+            ('tel. 501 234 567 / 22 123 45 67', 'tel. [Telefon] / [Telefon]'),
+            ('tel. 32 234 56 71 15.00-19.00', 'tel. [Telefon] 15.00-19.00'),
+            ('tel. 510 234 571 3. 12.01.2026 r. – 18.01.2026 r.',
+             'tel. [Telefon] 3. 12.01.2026 r. – 18.01.2026 r.'),
+            ('tel. 25 2345671 (155)', 'tel. [Telefon]'),
+            ('tel. 33 2345 671, wewnętrzny 60', 'tel. [Telefon]'),
+            ('tel. 86 234 56 71\n\nwewn. 122 Jan Kowalski\n\nwewn. 123 Anna Nowak',
+             'tel. [Telefon]\n\nwewn. [Telefon] Jan Kowalski\n\nwewn. [Telefon] Anna Nowak'),
+            ('Kontakt: (32) 234-56-71 lub bezpłatny numer alarmowy: 994',
+             'Kontakt: [Telefon] lub bezpłatny numer alarmowy: [Telefon]'),
+            ('за номером телефону: 452-234-571', 'за номером телефону: [Telefon]'),
+            ('Imie i nazwisko\nNr. Pokoju\nNr. Telefonu\nJan Kowalski\n4\n501 234 567',
+             'Imie i nazwisko\nNr. Pokoju\nNr. Telefonu\nJan Kowalski\n4\n[Telefon]'),
+            ('Referent Jan Kowalski 501 234 567 a@example.com\n\nPsycholog Anna Nowak 22 123 45 67 b@example.com',
+             'Referent Jan Kowalski [Telefon] [PII]\n\nPsycholog Anna Nowak [Telefon] [PII]'),
+            ('Infolinia pomaga znaleźć odpowiednie wsparcie.\n\n800 234 571\n\nPon-pt 10.00-21.00',
+             'Infolinia pomaga znaleźć odpowiednie wsparcie.\n\n[Telefon]\n\nPon-pt 10.00-21.00'),
+            ('NIP Powiatu Przykładowego: 123-45-63-218\nREGON Powiatu Przykładowego: 123456785',
+             'NIP Powiatu Przykładowego: [PII]\nREGON Powiatu Przykładowego: [PII]'),
+        ]
+        negatives = [
+            'Kontakt: cena 500 100 200 PLN',
+            'Telefon: 15.00-19.00',
+            'tel. 501 234 567\n\nNowa tabela.\n\n502234571',
+            'Statystyki infolinii.\n\n800 234 571\n\nLiczba zgłoszeń',
+            'Referent: 501 234 567',
+            'wewn. 123 Anna Nowak',
+            'Nr. Telefonu\nKod produktu 501 234 567',
+            'Imie i nazwisko\nNr. Pokoju\nNr. Telefonu\nKwota 501 234 567 zł',
+        ]
+        cases.extend((s, s.replace('501 234 567', '[Telefon]', 1) if s.startswith('tel. ') else s)
+                     for s in negatives)
+        for text, expected in cases:
+            with self.subTest(text=text):
+                spans = []
+                out, counts = scrub_pii(text, spans=spans)
+                self.assertEqual(out, expected)
+                rebuilt = text
+                for span in sorted(spans, key=lambda s: s['start'], reverse=True):
+                    self.assertEqual(text[span['start']:span['end']], span['text'])
+                    tag = '[Telefon]' if span['label'] == 'phone' else '[PII]'
+                    rebuilt = rebuilt[:span['start']] + tag + rebuilt[span['end']:]
+                self.assertEqual(rebuilt, out)
+                self.assertEqual(self._scrub(out), (out, dict.fromkeys(counts, 0)))
+
+    def test_explicit_access_pins(self):
+        for text, expected in (
+            ('PIN: \u202a123 456 789#', 'PIN: [PII]'),
+            ('kod PIN: 1234', 'kod PIN: [PII]'),
+            ('https://example.org/meet?pin=1234567890123&lang=pl',
+             'https://example.org/meet?pin=[PII]&lang=pl'),
+        ):
+            out, counts = self._scrub(text)
+            self.assertEqual(out, expected)
+            self.assertEqual(counts['pin'], 1)
+            self.assertEqual(counts['phone'], 0)
+            self.assertEqual(self._scrub(out), (out, dict.fromkeys(counts, 0)))
+        for text in ('Kod pocztowy: 00-123', 'ISBN 978-83-60823-07-01',
+                     'spin=12345678', 'PIN: 1234 PLN', 'PIN: 12345678901234567',
+                     'PIN: 1234abc', 'PIN: [PII]'):
+            self.assertEqual(self._scrub(text)[0], text)
+
+    def test_shared_contact_lists_and_phone_ranges(self):
+        cases = [
+            ('Numery kontaktowe:\n\nMIASTO ALFA – 85 234 56 71,\n\nMIASTO BETA – 86 234 56 72,\n\nMIASTO GAMMA – 87 234 56 73.',
+             'Numery kontaktowe:\n\nMIASTO ALFA – [Telefon],\n\nMIASTO BETA – [Telefon],\n\nMIASTO GAMMA – [Telefon].'),
+            ('Telefony zaufania (Polska, numery bezpłatne):\n 116 111 – Telefon Zaufania dla Dzieci i Młodzieży (czynny codziennie, możliwość kontaktu także przez czat)\n 800 23 4567 – Centrum Wsparcia',
+             'Telefony zaufania (Polska, numery bezpłatne):\n [Telefon] – Telefon Zaufania dla Dzieci i Młodzieży (czynny codziennie, możliwość kontaktu także przez czat)\n [Telefon] – Centrum Wsparcia'),
+            ('Numery kontaktowe:\n\nGdańsk: 58 123 45 67\n\nKraków: 12 345 67 89',
+             'Numery kontaktowe:\n\nGdańsk: [Telefon]\n\nKraków: [Telefon]'),
+            ('Telefony zaufania:\n• 116 123 – Wsparcie dorosłych\n\n• 800 123 456 – Pomoc',
+             'Telefony zaufania:\n• [Telefon] – Wsparcie dorosłych\n\n• [Telefon] – Pomoc'),
+            ('Tel.: (420) 222 345 671 – 222 345 672', 'Tel.: [Telefon]'),
+            ('Tel. (420) 222 111 222 - 222 111 333 wew. 42', 'Tel. [Telefon]'),
+            ('tel. 58 123 45 67 — 58 123 45 68', 'tel. [Telefon]'),
+            ('Numery kontaktowe:\n\nGdańsk: 58 123 45 67\n\nWarunki korzystania.\n\nKraków: 12 345 67 89',
+             'Numery kontaktowe:\n\nGdańsk: [Telefon]\n\nWarunki korzystania.\n\nKraków: 12 345 67 89'),
+            ('Telefony zaufania:\n116 123 – ' + 'Opis usługi. ' * 8 + '500 123 456 zgłoszeń',
+             'Telefony zaufania:\n[Telefon] – ' + 'Opis usługi. ' * 8 + '500 123 456 zgłoszeń'),
+        ]
+        negatives = [
+            'Tabela (420) 222 111 222 – 222 111 333',
+            'tel. (420) 222 111 222 – 222 111 333 EUR',
+            'Numery kontaktowe:\n\nKody taryfowe\n250300000\n250410000',
+            'Numery kontaktowe:\n\nGdańsk: 500 123 456 zł',
+            'Numery kontaktowe:\n\nKod: 501234567',
+            'Numery kontaktowe:\n\nWarunki korzystania z usługi.\n\nGdańsk: 58 123 45 67',
+            'Telefony zaufania:\n\nStatystyki\n800 123 456 – Liczba zgłoszeń',
+            'W artykule opisano numery kontaktowe:\n\nGdańsk: 58 123 45 67',
+            'Telefony zaufania:\n\n116 123 zł – Koszt programu',
+            'Numery kontaktowe:\n\n250300000\n250410000',
+            'Numery kontaktowe (20260908):',
+        ]
+        cases.extend((text, text) for text in negatives)
+        for text, expected in cases:
+            with self.subTest(text=text):
+                spans = []
+                out, counts = scrub_pii(text, spans=spans)
+                self.assertEqual(out, expected)
+                self.assertEqual(counts['phone'], expected.count('[Telefon]'))
+                self.assertEqual((out, counts), self._scrub(text))
+                rebuilt = text
+                end = len(text)
+                for span in sorted(spans, key=lambda s: s['start'], reverse=True):
+                    self.assertLessEqual(span['end'], end)
+                    self.assertEqual(text[span['start']:span['end']], span['text'])
+                    rebuilt = rebuilt[:span['start']] + '[Telefon]' + rebuilt[span['end']:]
+                    end = span['start']
+                self.assertEqual(rebuilt, out)
+                self.assertEqual(self._scrub(out), (out, dict.fromkeys(counts, 0)))
+
+    def test_contact_values_review_regressions(self):
+        cases = [
+            ('tel. (03141) 23456', 'tel. [Telefon]'),
+            ('tel. (03143) 2-34-56', 'tel. [Telefon]'),
+            ('numer bezpłatny: +1-202-555-0142', 'numer bezpłatny: [Telefon]'),
+            ('Toll Free: 888-555-0142, Phone: 207-555-0143',
+             'Toll Free: [Telefon], Phone: [Telefon]'),
+            ('Straż pożarna (Lánglovagok/Пожежна служба): 101\n'
+             'Policja (Rendőrség/Поліція): 102\n'
+             'Pogotowie (Mentőautó/Швидка допомога): 103',
+             'Straż pożarna (Lánglovagok/Пожежна служба): [Telefon]\n'
+             'Policja (Rendőrség/Поліція): [Telefon]\n'
+             'Pogotowie (Mentőautó/Швидка допомога): [Telefon]'),
+            ('tel. 112', 'tel. [Telefon]'),
+            ('lost&found@example.com.', '[PII].'),
+            ('Lostandfound@sub.example.com.', '[PII].'),
+            ('☏ +36 20 234-5671. 08:00–21:00.', '☏ [Telefon]. 08:00–21:00.'),
+            ('☏ +33 558234567. 12:00-02:00.', '☏ [Telefon]. 12:00-02:00.'),
+            ('telefon (+4 0723456712 - +4 to kod).', 'telefon ([Telefon] - +4 to kod).'),
+            ('tel. (+32 22345671)', 'tel. [Telefon]'),
+        ]
+        negatives = ['Tabela (03141) 23456', 'Phone: 207-555-0143 USD',
+                     'Toll Free: opis produktu 207-555-0143', 'numer bezpłatny: 2020-01-15',
+                     'Policja: 102 zł', 'Policja zatrzymała 102 osoby', 'Kod: 101',
+                     'Pogotowie: budynek 103', 'Policja:\n\n102',
+                     'phonebook 207-555-0143', 'systemd-fsck@.service.8.gz']
+        cases.extend((text, text) for text in negatives)
+        for text, expected in cases:
+            with self.subTest(text=text):
+                spans = []
+                out, counts = scrub_pii(text, spans=spans)
+                self.assertEqual(out, expected)
+                self.assertEqual((out, counts), self._scrub(text))
+                rebuilt = text
+                for span in sorted(spans, key=lambda s: s['start'], reverse=True):
+                    self.assertEqual(text[span['start']:span['end']], span['text'])
+                    tag = '[Telefon]' if span['label'] == 'phone' else '[PII]'
+                    rebuilt = rebuilt[:span['start']] + tag + rebuilt[span['end']:]
+                self.assertEqual(rebuilt, out)
+                self.assertEqual(self._scrub(out), (out, dict.fromkeys(counts, 0)))
+
+    def test_contact_challenge_phone_misses(self):
+        for text, expected in (
+            ('Biuro, +39 0964 234567, faks: +39 0964 234567.',
+             'Biuro, [Telefon], faks: [Telefon].'),
+            ('Tel.+39.030.234561 · Fax+39.030.2345671.',
+             'Tel.[Telefon] · Fax[Telefon].'),
+            ('Tel: (0) 611 2345. Tel: (0) 611 2346.',
+             'Tel: [Telefon]. Tel: [Telefon].'),
+            ('Biuro, +44 20 7946 0958; fax: +44 20 7946 0959',
+             'Biuro, [Telefon]; fax: [Telefon]'),
+            ('Tel: (0) 611 2345 wew. 42', 'Tel: [Telefon]'),
+            ('Tabela +39 0964 234567', 'Tabela +39 0964 234567'),
+            ('Tabela (0) 611 2345', 'Tabela (0) 611 2345'),
+            ('Tel. 01.03.2020', 'Tel. 01.03.2020'),
+            ('Kwota +39 0964 234567 EUR, faks: wymagany',
+             'Kwota +39 0964 234567 EUR, faks: wymagany'),
+            ('Tabela +39 0964 234567\n\nfaks: +39 0964 234567',
+             'Tabela +39 0964 234567\n\nfaks: [Telefon]'),
+            ('Kod +39 0964 234567, faks: +39 0964 234567',
+             'Kod +39 0964 234567, faks: [Telefon]'),
+        ):
+            with self.subTest(text=text):
+                spans = []
+                out, counts = scrub_pii(text, spans=spans)
+                self.assertEqual(out, expected)
+                self.assertEqual((out, counts), self._scrub(text))
+                rebuilt = text
+                for span in sorted(spans, key=lambda s: s['start'], reverse=True):
+                    self.assertEqual(text[span['start']:span['end']], span['text'])
+                    rebuilt = rebuilt[:span['start']] + '[Telefon]' + rebuilt[span['end']:]
+                self.assertEqual(rebuilt, out)
+                self.assertEqual(self._scrub(out), (out, dict.fromkeys(counts, 0)))
+
+    def test_redaction_placeholders_do_not_become_phone_cues(self):
+        for padding in range(25, 40):
+            text = 'tel. 501 234 567' + ' x' * padding + ' 602 345 678'
+            once, _ = self._scrub(text)
+            twice, counts = self._scrub(once)
+            self.assertEqual(twice, once)
+            self.assertEqual(sum(counts.values()), 0)
+        for marker in ('[Telefon]', '[PII]'):
+            text = marker + ' - opis 602 345 678'
+            self.assertEqual(self._scrub(text)[0], text)
+            for gap in ('\n\n', ' - opis\n\n'):
+                text = marker + gap + '602 345 678'
+                self.assertEqual(self._scrub(text)[0], text)
+                self.assertEqual(self._scrub('Telefon: ' + text)[0], 'Telefon: ' + text)
+        self.assertEqual(self._scrub('[Telefon] nowy tel. 602345678')[0],
+                         '[Telefon] nowy tel. [Telefon]')
+
+    def test_explicit_passport_variants_and_qualified_ids(self):
+        for label, number in (
+            ('paszport dyplomatyczny nr ', '1234'),
+            ('Paszport dyplomatyczny nr ', 'D000001234'),
+            ('Nr paszportu: ', 'D9001234'),
+            ('Nr paszportu: ', 'C2001234'),
+            ('Numer paszportu: ', 'D 001234'),
+            ('NIP Gminy: ', '123-456-32-18'),
+            ('REGON Gminy: ', '123456785'),
+        ):
+            with self.subTest(label=label, number=number):
+                self.assertEqual(self._scrub(label+number+'.')[0], label+'[PII].')
+        for text in ('Paszport wydany w 2017 roku', 'Paszport 2017',
+                     'paszport dyplomatyczny 2020', 'Model D9001234',
+                     'NIP firmy jest wymagany; kod 1234563218'):
+            self.assertEqual(self._scrub(text)[0], text)
+
+    def test_foreign_phone_cues_and_parenthesized_country_codes(self):
+        for label, number in (
+            ('Faks', '+32 22345671'),
+            ('faksem ', '(+32 22345671)'),
+            ('tel. ', '(+34) 965234571'),
+            ('tel. ', '(420) 222 345 671'),
+            ('telefon ', '(32-2) 234 56 71'),
+            ('faks ', '(49-69) 23 45-671/672'),
+            ('Faks: ', '(00) 49 69 23/45 -6 71'),
+        ):
+            with self.subTest(label=label, number=number):
+                self.assertEqual(self._scrub(label+number)[0], label+'[Telefon]')
+        for text in ('Tabela (420) 222 345 671', 'Tabela +32 22345671',
+                     'tel. (420) 222 345 671 EUR'):
+            self.assertEqual(self._scrub(text)[0], text)
+
+    def test_electronic_addresses_and_krs(self):
+        for text, expected, kind in (
+            ('Adres do e-Doręczeń: AE:PL-12345-67890-ABCDE-12.',
+             'Adres do e-Doręczeń: [PII].', 'electronic_address'),
+            ('E-PUAP: /przyklad123/SkrytkaESP', 'E-PUAP: [PII]', 'electronic_address'),
+            ('EPUAP Urzędu /urzad/SkrytkaESP; /urzad/skrytka; /urzad/inna',
+             'EPUAP Urzędu [PII]; [PII]; [PII]', 'electronic_address'),
+            ('Elektroniczna Skrzynka Podawcza na platformie E-PUAP: /urzad/skrytka',
+             'Elektroniczna Skrzynka Podawcza na platformie E-PUAP: [PII]', 'electronic_address'),
+            ('KRS: 651234; KRS 0000123457.', 'KRS: [PII]; KRS [PII].', 'krs'),
+        ):
+            with self.subTest(text=text):
+                out, counts = self._scrub(text)
+                self.assertEqual(out, expected)
+                self.assertGreater(counts[kind], 0)
+                self.assertEqual(self._scrub(out), (out, dict.fromkeys(counts, 0)))
+        for text in ('Ścieżka /usr/local', 'E-PUAP: https://example.com/usr/local',
+                     'KRS wymagany, kod 651234', 'KRS 1234567890123',
+                     'KRS 123456 789012 345678', 'KRS 651234 zł',
+                     'ORCID: 0000-0001-2345-6789', 'AE:PL-12345-67890-ABCDE-120'):
+            with self.subTest(text=text):
+                self.assertEqual(self._scrub(text)[0], text)
+
+    def test_extension_and_continuation_after_confirmed_phone(self):
+        for text, expected in (
+            ('tel. 22 234 56 71 lub 234 56 72 wew. 402, pokój nr 14',
+             'tel. [Telefon] lub [Telefon], pokój nr 14'),
+            ('tel. 00966 2345671, wew. 109, fax. 00966 234 5672',
+             'tel. [Telefon], fax. [Telefon]'),
+            ('tel. 25/234 56 71 wew. 48 pokój nr 9', 'tel. [Telefon] pokój nr 9'),
+            ('tel. 501234567 albo 1234567', 'tel. [Telefon] albo [Telefon]'),
+            ('wew. 402', 'wew. 402'),
+            ('tel. 501234567 pokój nr 14', 'tel. [Telefon] pokój nr 14'),
+            ('tel. 501234567 lub kwota 1234567 zł', 'tel. [Telefon] lub kwota 1234567 zł'),
+            ('tel. 501234567 wew. 402 zł', 'tel. [Telefon] wew. 402 zł'),
+            ('tel. 501234567 wew. 1234567', 'tel. [Telefon] wew. 1234567'),
+        ):
+            with self.subTest(text=text):
+                self.assertEqual(self._scrub(text)[0], expected)
+
+    def test_email_domain_requires_nonempty_labels(self):
+        for text in ('systemd-fsck@.service.8.gz', 'x@-example.com', 'x@example-.com',
+                     'x@example..com'):
+            with self.subTest(text=text):
+                self.assertEqual(self._scrub(text)[0], text)
+        self.assertEqual(self._scrub('a@sub-domain.example.com.')[0], '[PII].')
+
+    def test_foreign_phone_line_wrapping(self):
+        self.assertEqual(self._scrub('tel. +49\n711\n234\n5671')[0], 'tel. [Telefon]')
+        self.assertEqual(self._scrub('tel. +49 711 234 5671\n2. Szkoła')[0],
+                         'tel. [Telefon]\n2. Szkoła')
+
+    def test_short_phone_lists_and_foreign_trunk_numbers(self):
+        for raw, expected in (
+            ('tel. 523-45-61, 523-45-62; 517 234', 'tel. [Telefon], [Telefon]; [Telefon]'),
+            ('Tel. 09191 234567', 'Tel. [Telefon]'),
+            ('tel. (032) 23 45 67', 'tel. [Telefon]'),
+            ('Numer telefonu: 79 234 567', 'Numer telefonu: [Telefon]'),
+            ('tel. 501234567, kod 1234567', 'tel. [Telefon], kod 1234567'),
+            ('HAL Id: tel. 01279041', 'HAL Id: tel. 01279041'),
+        ):
+            with self.subTest(raw=raw):
+                self.assertEqual(self._scrub(raw)[0], expected)
+
+    def test_extended_phone_formats(self):
+        for number in ("74/234 56 71", "095/ 23 45 671", "261-234-571",
+                       "47 234 56 71", "826-45-67", "51 23 45",
+                       "+49 (0)711 234 56 76", "+39 057123451",
+                       "+32 22345671", "+1 202-555-0144", "00966 2345671",
+                       "12 23 45 671-673", "+251 11 234 56 71/72"):
+            with self.subTest(number=number):
+                out, counts = self._scrub('tel. ' + number)
+                self.assertEqual(out, 'tel. [Telefon]')
+                self.assertEqual(counts['phone'], 1)
+                self.assertEqual(sum(counts.values()), 1)
+
+    def test_short_numbers_require_immediate_phone_label(self):
+        for text in ("Tabela 826-45-67", "tel. opis tabeli 1234567",
+                     "tel. 501234567 kwota 1234567 zł", "tel. 2020-01-15"):
+            with self.subTest(text=text):
+                self.assertIn(text.split(' ')[-1], self._scrub(text)[0])
+
+    def test_labelled_damaged_identifiers(self):
+        for label, number, kind in (("PESEL: ", "44051401457", "pesel"),
+                                    ("PESEL:\n", "44O514O1457", "pesel"),
+                                    ("NIP: ", "123-456-32-19", "nip"),
+                                    ("REGON: ", "123456786", "regon"),
+                                    ("Dowód osobisty: ", "ABA400000", "document"),
+                                    ("Numer paszportu: ", "120012345", "document")):
+            with self.subTest(label=label, number=number):
+                out, counts = self._scrub(label + number + '. Koniec.')
+                self.assertEqual(out, label + '[PII]. Koniec.')
+                self.assertEqual(counts[kind], 1)
+
+    def test_identifier_context_does_not_eat_prose_or_long_accounts(self):
+        self.assertEqual(self._scrub('PESEL: 44051401457 i coś dalej')[0],
+                         'PESEL: [PII] i coś dalej')
+        for text in ("PESEL wymagany, kod 44051401457", "NIP brak 1234563219",
+                     "REGON\n\n123456786", "PESEL 12345678901234567890",
+                     "Paszport wydany w 2017 roku", "Model ABA400000"):
+            with self.subTest(text=text):
+                self.assertEqual(self._scrub(text)[0], text)
+
+    def test_registration_contact_cues(self):
+        for label in ("Zapisy pod numerem: ", "Rejestracja: pod numerem ",
+                      "Kontakt pod nr. ", "SZYBKI KONTAKTTel. kontaktowy: "):
+            with self.subTest(label=label):
+                out, counts = self._scrub(label + "501 234 567")
+                self.assertEqual(out, label + "[Telefon]")
+                self.assertEqual(counts['phone'], 1)
+
+    def test_contact_cues_do_not_match_other_number_fields(self):
+        for text in ("Sprawa pod numerem 501234567", "Hotel: 501234567",
+                     "Umowa pod numerem 501234567", "Sprawa pod numerem:\n\n501234567",
+                     "Zapisy pod numerem: 501234567 zł",
+                     "Zapisy dotyczą sprawy pod numerem 501234567"):
+            with self.subTest(text=text):
+                self.assertEqual(self._scrub(text)[0], text)
+
+    def test_phone_stops_before_opening_hours(self):
+        for phone in ("513 234 571", "+48 513 234 571", "22 123 45 67"):
+            for hours in (" (9:00-15:00)", " 09:00–15:00", "\t(19:30-20:00)",
+                          " 15.00 - 19.00", " (9.00 – 15.00)"):
+                with self.subTest(phone=phone, hours=hours):
+                    text = f"Telefon: {phone}{hours} mail: a@example.com"
+                    out, counts = self._scrub(text)
+                    self.assertEqual(out, f"Telefon: [Telefon]{hours} mail: [PII]")
+                    self.assertEqual(counts['phone'], 1)
+
+    def test_national_ids_require_explicit_adjacent_labels(self):
+        for label, number, kind in (
+            ("REGON: ", REGON9, "regon"),
+            ("nr REGON ", REGON9, "regon"),
+            ("numer regon:\n", REGON14, "regon"),
+            ("REGON nr: ", REGON9, "regon"),
+            ("NIP = ", NIP, "nip"),
+            ("numer NIP:\n", "PL123-45-63-218", "nip"),
+        ):
+            with self.subTest(label=label):
+                out, counts = self._scrub(label + number)
+                self.assertEqual(out, label + "[PII]")
+                self.assertEqual(counts[kind], 1)
+
+    def test_tariff_codes_are_not_regons(self):
+        # Real EUR-Lex commodity codes happen to pass the REGON checksum.
+        text = "WYKAZ A\n250410000 |\n250490000 |\n250860000 |"
+        out, counts = self._scrub(text)
+        self.assertEqual(counts['regon'], 0)
+        self.assertEqual(out, text)
+
+    def test_numeric_tables_are_not_phones(self):
+        for text in ("Podatek od towarów i usług\n132 165 000\nPodatek akcyzowy\n62 600 000",
+                     "Kwota w EUR\nPrzeniesiona kwota\n+552 977 761",
+                     "CJK 𠎠 132000 203A0 0xF0 0xA0", "Kod 501234567",
+                     "Kod 123456785", "Tabela\n250.000.000\n13.853.000\n1"):
+            with self.subTest(text=text):
+                self.assertEqual(self._scrub(text)[0], text)
+
+    def test_phone_stops_before_next_section(self):
+        for phone in ("601 234 571", "222-345-671", "+48 601 234 571"):
+            text = f"tel. {phone}\n2. Szkoła oferuje zajęcia."
+            out, counts = self._scrub(text)
+            self.assertEqual(out, "tel. [Telefon]\n2. Szkoła oferuje zajęcia.")
+            self.assertEqual(counts['phone'], 1)
+
+    def test_glued_phone_label_and_international_prefix(self):
+        for text, expected in (("Telefon58 234 56 71", "Telefon[Telefon]"),
+                               ("☎ 501 234 567", "☎ [Telefon]"),
+                               ("Kontakt +48 501 234 567", "Kontakt [Telefon]"),
+                               ("Kontakt 0048 501 234 567", "Kontakt [Telefon]")):
+            self.assertEqual(self._scrub(text)[0], expected)
+
+    def test_phone_context_is_bounded(self):
+        for text in ("Telefon jest wymagany.\n\nKod 501234567",
+                     "tel. kod: 501234567",
+                     "telefon " + "tekst " * 20 + "501234567"):
+            with self.subTest(text=text):
+                self.assertEqual(self._scrub(text)[0], text)
+
+    def test_labels_do_not_reach_across_words_or_paragraphs(self):
+        for text in (f"Kod {NIP}", f"NIP wymagany, kod produktu {NIP}",
+                     f"REGON przedsiębiorcy. Kod {REGON9}",
+                     f"REGON\n\n{REGON9}", f"NIP " + " " * 80 + NIP,
+                     f"antyREGON: {REGON9}", f"REGONXYZ: {REGON9}",
+                     f"Kod {REGON14}"):
+            with self.subTest(text=text):
+                out, counts = self._scrub(text)
+                self.assertEqual(counts['nip'] + counts['regon'], 0)
+                self.assertNotIn('[PII]', out)
+
+    def test_foreign_phone_is_not_a_polish_national_id(self):
+        # Synthetic checksum-collision formats formerly became '+49 (0)[PII]' / '+39 [PII]'.
+        for text in ("faks: +49 (0)711 234 56 76", "tel. +39 057123451"):
+            with self.subTest(text=text):
+                out, counts = self._scrub(text)
+                self.assertEqual(out, 'faks: [Telefon]' if text.startswith('faks') else 'tel. [Telefon]')
+                self.assertEqual(counts['nip'] + counts['regon'], 0)
+
+    def test_polish_format_gaps(self):
+        cases = [
+            ("tel. 501\u00a0234\u00a0567", "tel. [Telefon]", "phone"),
+            ("tel. 501\u202f234\u2009567", "tel. [Telefon]", "phone"),
+            ("NIP: 123-45-63-218", "NIP: [PII]", "nip"),
+            ("NIP: PL1234563218", "NIP: [PII]", "nip"),
+            ("NIP: PL123-456-32-18", "NIP: [PII]", "nip"),
+            ("Kontakt: łukasz@example.com", "Kontakt: [PII]", "email"),
+            ("Kontakt: żaneta@żółw.example.com", "Kontakt: [PII]", "email"),
+        ]
+        for raw, expected, kind in cases:
+            with self.subTest(raw=raw):
+                out, counts = self._scrub(raw)
+                self.assertEqual(out, expected)
+                self.assertEqual(counts[kind], 1)
+                self.assertEqual(self._scrub(out), (out, dict.fromkeys(counts, 0)))
+
+    def test_adjacent_phones(self):
+        for separator in (" ", "  ", "\t", "\n"):
+            text = f"tel. 501 234 567{separator}22 123 45 67"
+            out, counts = self._scrub(text)
+            self.assertEqual(out, f"tel. [Telefon]{separator}[Telefon]")
+            self.assertEqual(counts["phone"], 2)
+
+    def test_foreign_ibans(self):
+        # Published example IBANs; numeric and alphanumeric BBANs, various lengths.
+        for iban in ("DE89370400440532013000", "GB82WEST12345698765432",
+                     "FR1420041010050500013M02606", "NO9386011117947",
+                     "UA213223130000026007233566001"):
+            for raw in (iban, iban.lower(), " ".join(iban[i:i+4] for i in range(0, len(iban), 4))):
+                with self.subTest(raw=raw):
+                    out, counts = self._scrub(f"Rachunek: {raw} do wpłat.")
+                    self.assertEqual(out, "Rachunek: [PII] do wpłat.")
+                    self.assertEqual(counts["account"], 1)
+                    self.assertEqual(sum(counts.values()), 1)
+
+    def test_invalid_ibans_are_not_accounts(self):
+        for raw in ("DE88370400440532013000", "DE8937040044053201300",
+                    "DE893704004405320130000", "ZZ89370400440532013000"):
+            with self.subTest(raw=raw):
+                out, counts = self._scrub(raw)
+                self.assertEqual(out, raw)
+                self.assertEqual(counts["account"], 0)
+
+    def test_labelled_identity_documents(self):
+        for label, number in (("Dowód osobisty: ", "ABA300000"),
+                              ("numer dowodu ", "ABA 300000"),
+                              ("dowodu osobistego nr ", "aba-300000"),
+                              ("Paszport nr: ", "AB1234567"),
+                              ("paszportu serii ", "AB 1234567")):
+            with self.subTest(label=label):
+                out, counts = self._scrub(label + number + ".")
+                self.assertEqual(out, label + "[PII].")
+                self.assertEqual(counts["document"], 1)
+
+    def test_conservative_identifier_policy(self):
+        for text in ("Model ABA300000, kod AB1234567", "jan (małpa) example.com",
+                     "Numer 12345678901234567890"):
+            with self.subTest(text=text):
+                self.assertEqual(self._scrub(text)[0], text)
+
+    def test_numeric_clusters_are_not_partially_scrubbed(self):
+        for text in ("Konto: 501 234 567 8901 2345 6789 0123",
+                     "wersja 3.79.25.482243121", "cena 500 100 200 PLN",
+                     "współrzędne 52.1234567890 N", "data 2020 - 01 - 15 rok",
+                     "faktura 1234 5678 9012 3456", "alarmowe:\n112\n997\n999"):
+            with self.subTest(text=text):
+                self.assertEqual(self._scrub(text)[0], text)
+
+    def test_monetary_amounts_survive(self):
+        # Real legal-text failures plus checksum-valid numbers that resemble IDs.
+        for text in ("grzywny do 500\u00a0000\u00a0000 złotych",
+                     "kwoty 159\u00a0179\u00a0632,2 mln zł",
+                     "grzywny do 250 000 000\n złotych",
+                     "wydatki 293.474.478 mln zł",
+                     "kwota 123456785 zł", "kwota 1234563218 PLN",
+                     "kwota 500 100 200 tys. złotych", "kwota 500 100 200,50 EUR",
+                     "kwota 500 100 200 złotego", "USD 500 100 200", "$500 100 200"):
+            with self.subTest(text=text):
+                out, counts = self._scrub(text)
+                self.assertEqual(out, text.replace('\u00a0', ' '))
+                self.assertEqual(sum(counts.values()), 0)
+
+    def test_money_context_does_not_hide_contacts(self):
+        for text, expected in (
+            ("Cena 100 zł, tel. 501 234 567", "Cena 100 zł, tel. [Telefon]"),
+            ("tel. 501 234 567, cena 100 zł", "tel. [Telefon], cena 100 zł"),
+            ("tel. 501 234 567.\nCena 100 zł", "tel. [Telefon].\nCena 100 zł"),
+            ("Kontakt euro@example.com", "Kontakt [PII]"),
+        ):
+            with self.subTest(text=text):
+                self.assertEqual(self._scrub(text)[0], expected)
+
     def _scrub(self, text):
         return scrub_pii(text)
 
@@ -34,7 +663,7 @@ class ScrubPiiTest(unittest.TestCase):
         self.assertEqual(counts["phone"], 2)
 
     def test_leading_zero_landline(self):
-        out, counts = self._scrub("Siedziba: 022 123 45 67 w Warszawie.")
+        out, counts = self._scrub("Siedziba: tel. 022 123 45 67 w Warszawie.")
         self.assertIn("[Telefon]", out)
         self.assertNotIn("022", out)
         self.assertEqual(counts["phone"], 1)
@@ -59,14 +688,14 @@ class ScrubPiiTest(unittest.TestCase):
         self.assertNotIn("501", out)
 
     def test_foreign_uk_bare(self):
-        out, counts = self._scrub("London office 020 7946 0958 weekday mornings.")
+        out, counts = self._scrub("London office, tel. 020 7946 0958 weekday mornings.")
         self.assertIn("[Telefon]", out)
         self.assertNotIn("7946", out)
         self.assertEqual(counts["phone"], 1)
 
     def test_pesel_nip_regon_iban(self):
         text = (
-            f"PESEL {PESEL}, NIP {NIP}, REGON {REGON9} / {REGON14}, "
+            f"PESEL {PESEL}, NIP {NIP}, REGON {REGON9}, REGON {REGON14}, "
             f"konto {IBAN}."
         )
         out, counts = self._scrub(text)
@@ -106,17 +735,17 @@ class ScrubPiiTest(unittest.TestCase):
         self.assertEqual(sum(counts.values()), 0)
 
     def test_idempotent(self):
-        once, _ = self._scrub(f"mail a@b.pl tel +48 501 234 567 PESEL {PESEL}")
+        once, _ = self._scrub(f"mail a@example.com tel +48 501 234 567 PESEL {PESEL}")
         twice, counts = self._scrub(once)
         self.assertEqual(once, twice)
         self.assertEqual(sum(counts.values()), 0)
 
-    def test_postal_code_and_krs_survive(self):
+    def test_postal_code_survives_but_labelled_krs_is_redacted(self):
         text = "Kod 02-123 Warszawa, KRS 0000123456, kwota 500,00 zł."
         out, counts = self._scrub(text)
-        self.assertEqual(out, text)
+        self.assertEqual(out, 'Kod 02-123 Warszawa, KRS [PII], kwota 500,00 zł.')
         self.assertEqual(counts["phone"], 0)
-        self.assertEqual(sum(counts.values()), 0)
+        self.assertEqual(counts['krs'], 1)
 
     def test_kw_and_postal_range_survive(self):
         text = "KW KR1P/00012345/6, kod 00-950, okres 2020-2024."
@@ -159,18 +788,18 @@ class ScrubPiiTest(unittest.TestCase):
         self.assertEqual(counts["regon"], 0)
 
     def test_complex_email_formats(self):
-        addr = "jan.k+alert@pwr.edu.pl"
+        addr = "jan.k+alert@example.com"
         out, counts = self._scrub(f"Kontakt: {addr}")
         self.assertNotIn(addr, out)
         self.assertEqual(counts["email"], 1)
-        nested = "jan.kowalski+test@subdomain.example.pwr.edu.pl"
+        nested = "jan.kowalski+test@subdomain.example.com"
         out, counts = self._scrub(nested)
         self.assertNotIn(nested, out)
         self.assertEqual(counts["email"], 1)
 
     def test_pii_inside_brackets_or_quotes(self):
-        out, counts = self._scrub(f'("email: jan@ex.com", PESEL: "{PESEL}")')
-        self.assertNotIn("jan@ex.com", out)
+        out, counts = self._scrub(f'("email: jan@example.com", PESEL: "{PESEL}")')
+        self.assertNotIn("jan@example.com", out)
         self.assertNotIn(PESEL, out)
         self.assertEqual(counts["email"], 1)
         self.assertEqual(counts["pesel"], 1)
@@ -215,9 +844,9 @@ class ScrubPiiTest(unittest.TestCase):
         self.assertEqual(counts["phone"], 0)
 
     def test_en_dash_grouped_phone(self):
-        out, counts = self._scrub("sekretariat tel. 65 544–47-32 od poniedziałku")
+        out, counts = self._scrub("sekretariat tel. 65 234–56-71 od poniedziałku")
         self.assertIn("[Telefon]", out)
-        self.assertNotIn("544", out)
+        self.assertNotIn("234", out)
         self.assertEqual(counts["phone"], 1)
 
     def test_ministry_file_numbers_are_not_phones(self):