1.1.1: grouped national phones without a label

Rules only; same weights, threshold and API. 841-dev 326/354 whole (324), 0 new false
characters; cue-less phone test 66/111 phones (37), scored once.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

CHANGELOG.md

@@ -8,6 +8,23 @@ Semver for this island:
 
 Accuracy is 841-dev, union at 0.95, 354 gold spans. A version that changes those numbers must update `hybrid.json` `eval` and the tables below.
 
+## 1.1.1
+
+Same weights, threshold and API. Rules SHA `ad5c51f7…`. The rules file is the frozen and scored candidate `7412261c…` with comment tags removed; its syntax tree is identical.
+
+- **Rules:** Polish phones in the grouped national forms are masked without a contact label: mobile `601 234 567` and landline `22 123 45 67` (area code optionally in parentheses), optional `+48`, one separator kind (space or hyphen) throughout. Not taken: plain 9-digit strings (still label-gated), amounts, round counts (`500 000 000`), decimal figures (`601 234 567,89`), and numbers after another identifier's label (NIP, REGON, codes). After a bare grouped phone, a list goes on only with complete Polish numbers.
+
+841-dev: 326/354 whole (1.1.0: 324), residual 23 (24), 0 new false characters; phone 147/169 (145). A frozen blind set of 150 web passages selected for unlabelled phones: phones wholly masked 66/111 (1.1.0: 37), all values 127/178 (98), 0 lost, 1 passage with new false characters. Dynaword (60,000 documents): 79 documents change, 247 phone spans added, 0 removed; in a reviewed sample 1 of 23 sampled documents' added spans was not a phone.
+
+| Version | Whole /354 | Residual | Rules FP | Union FP | Char P | Char R | What changed |
+|---|---:|---:|---:|---:|---:|---:|---|
+| 1.0.0 | 323 | 25 | 133 | 133 | 97.76% | 95.95% | First Hub snapshot |
+| 1.0.1 | 323 | 25 | 98 | 123 | 97.93% | 95.95% | Prefix-only glued-email trim |
+| 1.0.2 | 324 | 24 | 98 | 123 | 97.93% | 96.12% | Labelled country-area phone fix |
+| 1.0.3 | 324 | 24 | 98 | 123 | 97.93% | 96.12% | Label-note, e-Delivery and registry rules; placeholder and card fixes |
+| 1.1.0 | 324 | 24 | 98 | 123 | 97.93% | 96.12% | Batch API (`predict_many`, `scrub_many`), opt-in float16 |
+| 1.1.1 | 326 | 23 | 98 | 123 | 97.94% | 96.50% | Grouped national phones without a label |
+
 ## 1.1.0
 
 Same weights, rules, threshold and default outputs; `hybrid.json` `eval` is unchanged. New batch API and opt-in fp16.

README.md

@@ -13,7 +13,7 @@ tags:
 - hybrid
 ---
 
-# NERGAL 1.1.0
+# NERGAL 1.1.1
 
 **Named Entity Recognition with Grounded Additive Labels**
 
@@ -23,8 +23,8 @@ SlayerLab hybrid PII cleaner for Polish. Not a chat model. Not a drop-in `pipeli
 
 Python rules do the identifiers they can prove. A transformer NER head adds phone and other PII spans the regex misses. The cleaner **unions** the two on the original text, then replaces hits with `[Telefon]` or `[PII]`.
 
-- **Version:** `1.1.0` (`hybrid.json`, `CHANGELOG.md`)
-- **Ground:** `scrub_pii` regex (SHA256 `f32d5c54…`)
+- **Version:** `1.1.1` (`hybrid.json`, `CHANGELOG.md`)
+- **Ground:** `scrub_pii` regex (SHA256 `ad5c51f7…`)
 - **Additive labels:** XLM-RoBERTa-large token classifier, BIO tags `phone` / `pii`, threshold 0.95
 - **Throughput:** about 80k chars/s on one RTX 4090 with `scrub_many` + `dtype="float16"` and 3 processes (1.0.3: 23k)
 - **This snapshot:** seed `202609160`, **epoch 5** of a seven-epoch schedule
@@ -62,9 +62,9 @@ NERGAL is not designed to remove:
 
 These are intended exclusions; false positives can still mask some of this content.
 
-### Known gaps in 1.1.0
+### Known gaps in 1.1.1
 
-Unlabelled phones and identifiers, unusual formatting and damaged text can escape detection. **VINs and obfuscated emails** (such as `name (at) domain.pl`) are approved annotation targets, but that approval alone does not establish reliable support in the released 1.1.0 model. Do not rely on it to remove them consistently.
+Unlabelled phones and identifiers (the rules take a bare phone only in the grouped national forms `601 234 567` and `22 123 45 67`; a plain `601234567` needs a label or the model), unusual formatting and damaged text can escape detection. **VINs and obfuscated emails** (such as `name (at) domain.pl`) are approved annotation targets, but that approval alone does not establish reliable support in the released 1.1.1 model. Do not rely on it to remove them consistently.
 
 ## Versions
 
@@ -76,7 +76,22 @@ Unlabelled phones and identifiers, unusual formatting and damaged text can escap
 | 1.0.1 | 323 | 25 | 98 | 123 | 97.93% | 95.95% | Prefix-only glued-email trim |
 | 1.0.2 | 324 | 24 | 98 | 123 | 97.93% | 96.12% | Labelled country-area phone fix |
 | 1.0.3 | 324 | 24 | 98 | 123 | 97.93% | 96.12% | Label-note, e-Delivery and registry rules; placeholder and card fixes |
-| **1.1.0** | **324** | **24** | **98** | **123** | **97.93%** | **96.12%** | Batch API (`predict_many`, `scrub_many`), opt-in float16 |
+| 1.1.0 | 324 | 24 | 98 | 123 | 97.93% | 96.12% | Batch API (`predict_many`, `scrub_many`), opt-in float16 |
+| **1.1.1** | **326** | **23** | **98** | **123** | **97.94%** | **96.50%** | Grouped national phones without a label |
+
+## Cue-less phone test
+
+841-dev holds few phones without a label, so it barely moves for 1.1.1. This targeted test does: 150 web passages selected for phones with no contact label, labelled and frozen before any prediction, and scored once (2026-09-29). Union at 0.95, same model spans for both.
+
+| | 1.1.0 | **1.1.1** |
+|---|---:|---:|
+| Phones wholly masked /111 | 37 | **66** |
+| All values wholly masked /178 | 98 | **127** |
+| Positive passages fully covered /70 (95% CI) | 24 (0.23–0.47) | **37 (0.41–0.65)** |
+| Passages with false masks /150 | 3 | 4 |
+| False characters | 83 | 95 |
+
+1.1.1 lost no value 1.1.0 masked; its 12 new false characters are in one passage. The set is enriched by selection, so these numbers say nothing about how common such phones are, and it has a single reviewer.
 
 ## 841-dev
 
@@ -112,15 +127,15 @@ Same 841-dev split, threshold **0.95**. **Naked** is the transformer alone. **
 
 | System | Mode | Whole /354 | Residual | False chars | Char P | Char R |
 |---|---|---:|---:|---:|---:|---:|
-| Regex (`scrub_pii`) | rules | 259 | 70 | 98 | 98.13% | 85.04% |
+| Regex (`scrub_pii`) | rules | 263 | 68 | 98 | 98.15% | 85.78% |
 | GLiNER 2.5-multi zero-shot | naked | 81 | 188 | 970 | 56.98% | 21.22% |
 | GLiNER 2.5-multi zero-shot | ∪ regex | 273 | 61 | 1,068 | 83.33% | 88.16% |
 | Historical GLiNER email12 | naked | 249 | 70 | 10 | 99.81% | 85.39% |
 | Historical GLiNER email12 | ∪ regex | 290 | 50 | 108 | 98.13% | 93.76% |
 | XLM-R epoch 5 | naked | 298 | 42 | 57 | 98.96% | 89.38% |
-| **NERGAL 1.1.0** | **∪ regex** | 324 | 24 | 123 | 97.93% | 96.12% |
+| **NERGAL 1.1.1** | **∪ regex** | 326 | 23 | 123 | 97.94% | 96.50% |
 
-Zero-shot [GLiNER 2.5](https://huggingface.co/fastino/gliner2.5-multi-v1) is not competitive here, especially on non-phone PII (7/185 whole vs 160 naked / 179 union). Fine-tuned historical GLiNER is the precise naked baseline (10 false characters) and still trails XLM-R on coverage. NERGAL is XLM-R epoch 5 plus the regex: 145/169 phone, 179/185 other PII. Exact-span precision 86.34%, recall 89.27%, F1 87.78%.
+Zero-shot [GLiNER 2.5](https://huggingface.co/fastino/gliner2.5-multi-v1) is not competitive here, especially on non-phone PII (7/185 whole vs 160 naked / 179 union). Fine-tuned historical GLiNER is the precise naked baseline (10 false characters) and still trails XLM-R on coverage. NERGAL is XLM-R epoch 5 plus the regex: 147/169 phone, 179/185 other PII. Exact-span precision 86.41%, recall 89.83%, F1 88.09%. The two GLiNER ∪ regex rows use the 1.1.0 rules.
 
 Trained GLiNER, HerBERT-large, and XLM-R-large were also compared on this split (plot above). GLiNER’s 0.50 coverage lead is the precision collapse in that figure; no GLiNER or HerBERT operating point passed the content-preservation gate.
 
@@ -155,6 +170,6 @@ masked, counts = nergal.scrub(text)
 
 For many texts, `nergal.scrub_many(texts)` (or `predict_many` for the raw model spans) batches windows across texts: about 2× the throughput of calling `scrub` in a loop on a CUDA GPU. `from_pretrained(..., dtype="float16")` casts the weights at load time on CUDA or MPS: another 1.9× on an RTX 4090, and 841-dev union numbers are unchanged, but scores are not bit-identical to float32 (0.95 spans can differ in rare cases). For a corpus, run 2–3 processes per GPU, because float16 inference is limited by CPU-side tokenization. Measurements are in `CHANGELOG.md`.
 
-`hybrid.json` records version `1.1.0`, threshold 0.95, gap ids `250002` / `250003`, the 841-dev `eval` block, and two weight hashes: `model_safetensors_sha256` for the published file and `source_checkpoint_sha256` for the training checkpoint it was packed from. `test_nergal.py` is synthetic (no corpus text). From this snapshot: `python -m unittest test_nergal`.
+`hybrid.json` records version `1.1.1`, threshold 0.95, gap ids `250002` / `250003`, the 841-dev `eval` block, and two weight hashes: `model_safetensors_sha256` for the published file and `source_checkpoint_sha256` for the training checkpoint it was packed from. `test_nergal.py` is synthetic (no corpus text). From this snapshot: `python -m unittest test_nergal`.
 
 Base weights: [`FacebookAI/xlm-roberta-large`](https://huggingface.co/FacebookAI/xlm-roberta-large) revision `c23d21b0620b635a76227c604d44e43a9f0ee389` (MIT).

hybrid.json

@@ -1,25 +1,25 @@
 {
   "full_name": "Named Entity Recognition with Grounded Additive Labels",
   "hub_id": "SlayerLab/NERGAL",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "mode": "rules_union",
   "epoch": 5,
   "seed": 202609160,
   "threshold": 0.95,
-  "rules_sha256": "f32d5c5452fc47178e109d4bc248a0d8234ea6e59e8cf79407f4eb8451581d67",
+  "rules_sha256": "ad5c51f7c712dd2b7af40a337b703aeec211a57170a87c262bf9bd9386ba1925",
   "eval": {
     "split": "841-dev",
     "gold_entities": 354,
-    "whole_entities": 324,
-    "residual_passages": 24,
+    "whole_entities": 326,
+    "residual_passages": 23,
     "union_fp": 123,
     "rules_fp": 98,
-    "character_precision": 0.9793,
-    "character_recall": 0.9612,
-    "exact_precision": 0.8634,
-    "exact_recall": 0.8927,
-    "exact_f1": 0.8778,
-    "phone_whole": 145,
+    "character_precision": 0.9794,
+    "character_recall": 0.965,
+    "exact_precision": 0.8641,
+    "exact_recall": 0.8983,
+    "exact_f1": 0.8809,
+    "phone_whole": 147,
     "phone_gold": 169,
     "pii_whole": 179,
     "pii_gold": 185

nergal.py

@@ -17,13 +17,13 @@ import scrub_pii
 from scrub_pii import PHONE_TAG, PII_TAG
 
 HUB_ID = 'SlayerLab/NERGAL'
-VERSION = '1.1.0'
+VERSION = '1.1.1'
 GAPS = ['[PII_SPACE]', '[PII_BREAK]']
 GAP_IDS = [250002, 250003]
 BIO_LABELS = ['O', 'B-phone', 'I-phone', 'B-pii', 'I-pii']
 LABELS = ['phone', 'pii']
 THRESHOLD = 0.95
-RULES_SHA = 'f32d5c5452fc47178e109d4bc248a0d8234ea6e59e8cf79407f4eb8451581d67'
+RULES_SHA = 'ad5c51f7c712dd2b7af40a337b703aeec211a57170a87c262bf9bd9386ba1925'
 DTYPES = ('float32', 'float16')
 
 

scrub_pii.py

@@ -24,7 +24,8 @@ international country/trunk notation such as +CC (0). With a cue, the EUR-Lex
 "(32-2) 299 11 11" country-area form counts as international. Strong labels also
 admit one-digit country codes and wider hyphenated area codes. 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.
+domestic numbers are left for audit because table cells have the same shapes, except
+the grouped national forms: mobile 3-3-3 and landline 2-3-2-2, one separator kind.
 Flattened tables can glue labels to both neighbours ("Mödlingtel.: … 38112faks:");
 such glued labels count as labels and end the preceding number.
 
@@ -75,7 +76,7 @@ _PIN_RE = re.compile(
 _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.
+# 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",
@@ -184,6 +185,14 @@ _SERVICE_PHONE_LABEL_RE = re.compile(
     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)
+# Grouped national phones need no cue: web contact blocks write them bare. Plain 9-digit strings stay cue-gated,
+# since many unlabelled ones are not phones.
+_MOBILE_PREFIX = "45|50|51|53|57|60|66|69|72|73|78|79|88"
+_AREA_CODE = ("12|13|14|15|16|17|18|22|23|24|25|29|32|33|34|41|42|43|44|46|48|52|54|55|56|58|59|61|62|63|65|67|68|"
+              "71|74|75|76|77|81|82|83|84|85|86|87|89|91|94|95")
+_GROUPED_PHONE_RE = re.compile(
+    r"(?:\+48[ \t]?)?(?:(?:" + _MOBILE_PREFIX + r")\d(?P<m>[ -])\d{3}(?P=m)\d{3}"
+    r"|(?:\((?:" + _AREA_CODE + r")\)|(?:" + _AREA_CODE + r"))(?P<l>[ -])\d{3}(?P=l)\d{2}(?P=l)\d{2})")
 _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ń!?)"
@@ -204,7 +213,7 @@ _STAFF_ROLE_RE = re.compile(
 
 
 def _phone_list_context(text: str, start: int) -> bool:
-    # ponytail: 2,000-character lookback and 400-character entry suffix; longer
+    # 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:
@@ -285,7 +294,7 @@ def _directory_context(text: str, start: int, end: int) -> bool:
     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
+    # 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]
@@ -469,6 +478,25 @@ def _replace_land_registers(text: str, *, mask=_tag) -> tuple[str, int]:
     return _LAND_REGISTER_RE.sub(replace, text), n
 
 
+def _head(raw: str) -> str:
+    # The greedy match may run on over a newline or a slash; the break and pair logic in _replace_phones cut it there.
+    return re.split(r"[ \t]*[\n/]", raw, maxsplit=1)[0]
+
+
+def _national_head(raw: str) -> bool:
+    return _pl_national_ok(re.sub(r"^(?:48|0)(?=\d{9}$)", "", _digits(_head(raw))))
+
+
+def _grouped_phone(text: str, start: int, raw: str) -> bool:
+    # Digits glued before the number on its line ("48 601 234 567", list indexes) are not tried.
+    head = _head(raw)
+    return bool(_GROUPED_PHONE_RE.fullmatch(head)
+                and not re.search(r"[ -]000[ -]000\Z", head)  # round counts: 500 000 000
+                and not _is_amount(text, start, start + len(head))
+                and not re.match(r",\d{1,2}(?!\d)", text[start + len(head):])  # decimal figures: 601 234 567,89
+                and not _OTHER_NUMBER_LABEL_RE.search(text[max(0, start - 75):start]))
+
+
 def _pl_national_ok(d: str) -> bool:
     return len(d) == 9 and d.isdigit() and d[:2] in _PL_PREFIX
 
@@ -499,7 +527,7 @@ def _phone_ok(raw: str, short: bool = False) -> bool:
         return True
     if short and s.startswith('(0)'):
         return 7 <= len(d) <= 12
-    # ponytail: label + shape + length, not a country numbering-plan validator.
+    # 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
     # EUR-Lex puts country and area code in parentheses: "(32-2) 299 11 11" is +32 2 299 11 11.
@@ -509,7 +537,7 @@ def _phone_ok(raw: str, short: bool = False) -> bool:
         if s.startswith('00'):
             international = international[2:]
         if not international.startswith('48'):
-            # ponytail: explicit prefix + length, not a global numbering-plan
+            # 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"):
@@ -598,6 +626,7 @@ def _replace_phones(text: str, *, mask=_tag) -> tuple[str, int]:
     pos = 0
     last_phone_end = None
     last_phone_complete = False
+    last_phone_cued = False  # after a bare grouped phone a list goes on only with complete national numbers
     while True:
         m = _PHONE_RE.search(text, pos)
         if not m:
@@ -609,8 +638,10 @@ def _replace_phones(text: str, *, mask=_tag) -> tuple[str, int]:
         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.
+            next_end = next_end if next_end >= 0 else end
+            if (_directory_context(text, line_end+1, next_end)
+                    or _grouped_phone(text, line_end+1, text[line_end+1:next_end])):
+                # A flattened table's room cell or an address's house number is not a phone country prefix.
                 out.append(text[pos:line_end+1])
                 pos = line_end+1
                 continue
@@ -638,17 +669,19 @@ def _replace_phones(text: str, *, mask=_tag) -> tuple[str, int]:
         # "tel. +48 609 \n953 709", or the next local number, "(30) 25 10 22 33 25,\n22 33 28".
         cell = (last_phone_complete and 5 <= len(_digits(raw)) <= 6
                 and re.fullmatch(r'[ \t]*\n[ \t\n]*', text[last_phone_end:m.start()]))
-        if (last_phone_end is not None and not postal and not cell
+        continues = last_phone_cued or (last_phone_end is not None and _national_head(raw))
+        if (continues and not postal and not cell
                 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
+        if (continues
                 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 (novel_country_area_ok and (short or _phone_context(text, m.start(), raw)
-                or _directory_context(text, m.start(), line_end if line_end >= 0 else end))):
+        cued = (short or _phone_context(text, m.start(), raw)
+                or _directory_context(text, m.start(), line_end if line_end >= 0 else end))
+        if novel_country_area_ok and (cued or _grouped_phone(text, m.start(), raw)):
             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))
@@ -701,7 +734,7 @@ def _replace_phones(text: str, *, mask=_tag) -> tuple[str, int]:
                     start += 1
                 replacement = text[m.start():start] + mask(start, end, PHONE_TAG)
                 n += 1
-            # ponytail: split only pairs (<=22 digits); longer lists need label
+            # 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:
                 # A slash separates alternatives, the second without the shared
@@ -717,6 +750,7 @@ def _replace_phones(text: str, *, mask=_tag) -> tuple[str, int]:
         if replacement != raw:
             last_phone_end = end
             last_phone_complete = _phone_ok(raw)
+            last_phone_cued = bool(cued)
         pos = end
     return "".join(out), n
 

test_nergal.py

@@ -5,7 +5,7 @@ import unittest
 from pathlib import Path
 
 HERE = Path(__file__).resolve().parent
-RULES_SHA = 'f32d5c5452fc47178e109d4bc248a0d8234ea6e59e8cf79407f4eb8451581d67'
+RULES_SHA = 'ad5c51f7c712dd2b7af40a337b703aeec211a57170a87c262bf9bd9386ba1925'
 
 
 class NergalTests(unittest.TestCase):
@@ -13,7 +13,7 @@ class NergalTests(unittest.TestCase):
         from nergal import GAP_IDS, GAPS, HUB_ID, RULES_SHA as PINNED, THRESHOLD, VERSION
         card = json.loads((HERE / 'hybrid.json').read_text())
         self.assertEqual(HUB_ID, 'SlayerLab/NERGAL')
-        self.assertEqual(VERSION, '1.1.0')
+        self.assertEqual(VERSION, '1.1.1')
         self.assertEqual(card['version'], VERSION)
         self.assertEqual(card['eval']['union_fp'], 123)
         self.assertEqual(card['eval']['rules_fp'], 98)
@@ -62,6 +62,19 @@ class NergalTests(unittest.TestCase):
         self.assertEqual(text[span['start']:span['end']], '1234567802')
         self.assertEqual(rules('a [PII] b [Telefon] c'), [])
 
+    def test_grouped_national_phones_mask_without_a_cue(self):
+        from nergal import rules
+        for text, masked in (('Sklep Ala, 601 234 567, czynne 9-17', ['601 234 567']),
+                             ('Biuro: (22) 123 45 67.', ['(22) 123 45 67']),
+                             ('Zapraszamy: +48 601 234 567.', ['+48 601 234 567']),
+                             ('Zapraszamy: 601234567.', []),               # plain 9 digits stay cue-gated
+                             ('Budżet wyniósł 601 234 567 zł.', []),       # amount
+                             ('Wartość 601 234 567,89 w tabeli.', []),     # decimal figure
+                             ('Kwota 500 000 000 osób.', []),              # round count
+                             ('NIP: 601 234 567', [])):                    # other-number label
+            with self.subTest(text=text):
+                self.assertEqual([text[s['start']:s['end']] for s in rules(text) if s['label'] == 'phone'], masked)
+
     def test_union_keeps_regex_and_adds_model_spans(self):
         from nergal import apply_union, scrub_spans
         text = 'Ring 000000000 then extra.'