SCRUB-WP implement pure Zorgfilter recognizers

Implement sixteen context-bound care entities, pass all frozen contracts and corpus expectations, preserve clinical content and keep app registration gated.

CARE_RECOGNIZER_IMPLEMENTATION_V1.md

@@ -0,0 +1,76 @@
+# Zorgfilter v1 — pure recognizer implementation
+
+Status: implemented and contract-validated; app registration remains gated  
+Workpackage: `SCRUB-WP_CARE_PROFILE_RECOGNIZER_IMPLEMENTATION`
+
+## Result
+
+The pure module `dutch_care_recognizers.py` implements the frozen Zorgfilter v1 contract without changing the current application.
+
+Public API:
+
+```python
+get_dutch_care_entity_names()
+get_dutch_care_recognizers(supported_language="en")
+```
+
+Implemented entity families:
+
+- patient, client, medical-record and EPD/ECD identifiers;
+- health-insurance, referral, treatment and laboratory references;
+- care incident and care indication references;
+- strong-context AGB codes;
+- care-provider names after bounded professional roles;
+- labeled care organizations and bounded care locations;
+- room, bed and apartment references;
+- labeled care-event dates distinct from date of birth.
+
+## Validation result
+
+```text
+Dedicated entities: 16
+Frozen positive contracts: 37/37 passed
+Forbidden positive collisions: 0
+Frozen negative/collision contracts: 16/16 passed
+Dedicated expectations in eight-document corpus: 54/54 passed
+Protected clinical phrase overlaps: 0
+Full repository regression run #1854: 953 tests passed
+App registration: false
+Production readiness: false
+```
+
+Evidence:
+
+- `output/validation/care_recognizer_implementation_validation.json`
+- `tests/test_dutch_care_recognizers.py`
+- `tests/test_care_recognizer_validation.py`
+
+## Design choices
+
+### Strong care labels for references
+
+Patient-specific codes are recognized only after explicit labels such as patient number, client number, EPD/ECD number, referral number, sample number or incident number. The recognizer returns only the value span and preserves the label.
+
+### Provider roles remain readable
+
+A provider name is recognized only after bounded roles such as nurse, GP, treating specialist, personal carer, prescriber or incident reporter. The role and titles such as `dr.` remain readable.
+
+### Conservative organization and location handling
+
+Organization detection is restricted to labeled fields. Location detection is restricted to bounded phrases such as `location`, `ward`, `team` or `residential location`. The module does not infer every narrative organization as a care organization.
+
+### AGB collision protection
+
+AGB requires explicit AGB context and exactly eight digits. The dedicated module does not infer AGB from arbitrary numbers and passes the frozen BSN/BIG negative cases. Cross-recognizer precedence with the existing BSN recognizer remains an explicit profile-integration responsibility.
+
+### Clinical meaning is preserved
+
+The module does not match medication, dosage, administration times, vital signs, laboratory values, pain scores, DBC/ICD codes or role words without a person name. The eight-document corpus produced zero overlaps with protected clinical passages.
+
+## Integration boundary
+
+The recognizers are intentionally not imported or registered by `presidio_helpers.py` or `presidio_streamlit.py` in this package. The next workpackage centralizes profile composition so Zorg can be added without further scattering profile-specific `if` statements across the UI.
+
+No export, Scrub Key, reinsert, runtime, dependency or cloud-processing behavior changed.
+
+Human review remains mandatory. Passing the synthetic contract does not establish production readiness.

CHANGELOG.md

@@ -1,3 +1,42 @@
+## 2026-08-03 16:52 Europe/Amsterdam — SCRUB-WP_CARE_PROFILE_RECOGNIZER_IMPLEMENTATION
+
+Status: completed; pure recognizer implementation validated.
+
+Purpose:
+- Implement the frozen Zorgfilter recognizer contract without registering it in the current app.
+
+Files added:
+- `dutch_care_recognizers.py`
+- `care_recognizer_validation.py`
+- `CARE_RECOGNIZER_IMPLEMENTATION_V1.md`
+- `scripts/generate_care_recognizer_validation.py`
+- `tests/test_dutch_care_recognizers.py`
+- `tests/test_care_recognizer_validation.py`
+- `output/validation/care_recognizer_implementation_validation.json`
+- `workpackage_claims/scrub_wp_care_profile_recognizer_implementation.md`
+- `handover/workpackages/20260803_1652_care_profile_recognizer_implementation.md`
+
+Implementation result:
+- implemented sixteen dedicated, context-bound care entities;
+- returned exact value-only Presidio spans with explanations and metadata;
+- corrected bounded variants for Dutch client labels, prescription numbers, generic incident labels and lowercase residential-care organization labels;
+- passed all frozen positive and negative contracts;
+- covered all 54 dedicated corpus expectations with zero protected-clinical overlaps;
+- kept app registration explicitly false.
+
+Validation:
+- initial run #1850 exposed five bounded missing context variants and no clinical-overmasking failure;
+- corrected GitHub Actions run #1854 passed: 953 tests;
+- final clean validation pending after governance finalization;
+- Hugging Face sync not functionally relevant;
+- app verification not applicable.
+
+Intentionally not changed:
+- `presidio_helpers.py`, `presidio_streamlit.py` or current profile behavior;
+- thresholds, entity defaults or generic NER;
+- review, export, Scrub Key or reinsert semantics;
+- runtime, dependencies or cloud processing.
+
 ## 2026-08-03 16:34 Europe/Amsterdam — SCRUB-WP_CARE_PROFILE_RECOGNIZER_CONTRACT_TESTS
 
 Status: completed; test/specification contract frozen.

RISK_REGISTER.md

@@ -229,6 +229,8 @@ Gap triage classified all 81 expectations. The largest unresolved family is cont
 
 The recognizer contract is now frozen with sixteen dedicated entities, 37 positive exact-span cases and 16 negative/collision/preservation cases. Implementation must pass these fixtures before any app registration or UI promotion.
 
+The pure recognizer implementation now passes all frozen fixtures and all 54 dedicated corpus expectations with zero protected-clinical overlaps. Risk R10 remains open because generic NER composition, AGB/BSN cross-recognizer precedence, visible profile policy, cross-profile regression and live app verification are not yet complete.
+
 ---
 
 ## Product-claim boundary

ROADMAP.md

@@ -467,6 +467,8 @@ The existing broad `NL_HEALTHCARE_REFERENCE` category must be assessed and split
 
 Current-engine baseline evidence is now recorded: 25 of 81 expected replace/review values were found as exact normalized spans, only 14 under the intended entity type, 11 were misclassified and 56 were missed. The bounded custom-rule baseline produced zero overlaps with the designated clinical preserve passages. Generic NER was excluded, so PERSON and e-mail results are not full-app measurements.
 
+The dedicated pure recognizer implementation is now green but remains unregistered: sixteen care entities pass 37/37 positive contracts, 16/16 negative/collision contracts and all 54 dedicated expectations in the eight-document corpus, with zero protected-clinical overlaps. The next gate is central profile composition and AGB/BSN precedence before any visible Zorg profile is added.
+
 ### Current and final interface direction
 
 Current prototype after test-gated integration:

WORKPACKAGES.md

@@ -1,3 +1,47 @@
+## 2026-08-03 16:52 Europe/Amsterdam — SCRUB-WP_CARE_PROFILE_RECOGNIZER_IMPLEMENTATION
+
+Status: completed; pure recognizers implemented and contract-validated, app registration still closed.
+
+Goal:
+- Implement the frozen sixteen-entity Zorgfilter recognizer module without changing current app behavior.
+
+Result:
+
+```text
+Dedicated entities: 16
+Positive contracts: 37/37 passed
+Forbidden positive collisions: 0
+Negative/collision contracts: 16/16 passed
+Dedicated corpus expectations: 54/54 passed
+Protected clinical phrase overlaps: 0
+Full regression run #1854: 953 tests passed
+App registration: false
+```
+
+Implementation:
+- `dutch_care_recognizers.py` with value-only Presidio capture results;
+- strong-context administrative references and AGB;
+- provider-name recognition preserving professional roles;
+- labeled organizations and bounded locations;
+- room/bed/apartment references;
+- care-event dates separated from date of birth;
+- no Streamlit, network, AI, cloud or file-write behavior.
+
+Evidence:
+- `CARE_RECOGNIZER_IMPLEMENTATION_V1.md`
+- `output/validation/care_recognizer_implementation_validation.json`
+
+Active next package:
+- `SCRUB-WP_RECOGNITION_PROFILE_CONFIGURATION_REFACTOR`
+
+Boundaries:
+- recognizers are not registered in `presidio_helpers.py` or the UI;
+- generic PERSON/e-mail remain generic-profile dependencies;
+- AGB/BSN profile-level precedence remains to be validated;
+- no export, Scrub Key or reinsert change;
+- human review remains required;
+- production readiness remains false.
+
 ## 2026-08-03 16:34 Europe/Amsterdam — SCRUB-WP_CARE_PROFILE_RECOGNIZER_CONTRACT_TESTS
 
 Status: completed; recognizer contract frozen before implementation.

care_recognizer_validation.py

@@ -0,0 +1,139 @@
+"""Pure validation report for the Zorgfilter v1 recognizer implementation."""
+
+from __future__ import annotations
+
+from typing import Any, Dict
+
+from care_recognizer_contracts import ALL_POSITIVE_CASES, NEGATIVE_CASES
+from care_test_examples import TEST_CASES
+from dutch_care_recognizers import (
+    get_dutch_care_entity_names,
+    get_dutch_care_recognizers,
+)
+
+
+def _detect(text: str) -> list[dict[str, Any]]:
+    entities = get_dutch_care_entity_names()
+    rows: list[dict[str, Any]] = []
+    for recognizer in get_dutch_care_recognizers(supported_language="en"):
+        for result in recognizer.analyze(text, entities=entities, nlp_artifacts=None):
+            rows.append(
+                {
+                    "entity_type": result.entity_type,
+                    "start": int(result.start),
+                    "end": int(result.end),
+                    "text": text[result.start:result.end],
+                    "score": float(result.score),
+                    "recognizer": recognizer.name,
+                }
+            )
+    return sorted(rows, key=lambda row: (row["start"], row["end"], row["entity_type"]))
+
+
+def _has_exact(rows: list[dict[str, Any]], entity_type: str, value: str) -> bool:
+    return any(
+        row["entity_type"] == entity_type and row["text"] == value
+        for row in rows
+    )
+
+
+def build_care_recognizer_validation() -> Dict[str, Any]:
+    """Return deterministic contract and corpus implementation evidence."""
+
+    positive_failures: list[dict[str, Any]] = []
+    forbidden_positive_failures: list[dict[str, Any]] = []
+    for case in ALL_POSITIVE_CASES:
+        rows = _detect(case["text"])
+        if not _has_exact(rows, case["entity_type"], case["expected_value"]):
+            positive_failures.append(
+                {
+                    "id": case["id"],
+                    "entity_type": case["entity_type"],
+                    "expected_value": case["expected_value"],
+                    "detected": rows,
+                }
+            )
+        for forbidden_entity in case["forbidden_entities"]:
+            if _has_exact(rows, forbidden_entity, case["expected_value"]):
+                forbidden_positive_failures.append(
+                    {
+                        "id": case["id"],
+                        "forbidden_entity": forbidden_entity,
+                        "value": case["expected_value"],
+                    }
+                )
+
+    negative_failures: list[dict[str, Any]] = []
+    for case in NEGATIVE_CASES:
+        rows = _detect(case["text"])
+        violations = [
+            row for row in rows
+            if row["entity_type"] in set(case["forbidden_entities"])
+        ]
+        if violations:
+            negative_failures.append(
+                {
+                    "id": case["id"],
+                    "violations": violations,
+                }
+            )
+
+    dedicated_entities = set(get_dutch_care_entity_names())
+    corpus_expected = 0
+    corpus_found = 0
+    corpus_failures: list[dict[str, Any]] = []
+    preserve_overlaps: list[dict[str, Any]] = []
+    for case in TEST_CASES:
+        rows = _detect(case["text"])
+        for bucket in ("replace", "review_selected"):
+            for expectation in case[bucket]:
+                if expectation["entity_type"] not in dedicated_entities:
+                    continue
+                corpus_expected += 1
+                if _has_exact(rows, expectation["entity_type"], expectation["value"]):
+                    corpus_found += 1
+                else:
+                    corpus_failures.append(
+                        {
+                            "case_id": case["id"],
+                            "entity_type": expectation["entity_type"],
+                            "value": expectation["value"],
+                        }
+                    )
+        for phrase in case["preserve"]:
+            phrase_start = case["text"].index(phrase)
+            phrase_end = phrase_start + len(phrase)
+            for row in rows:
+                if phrase_start < row["end"] and row["start"] < phrase_end:
+                    preserve_overlaps.append(
+                        {
+                            "case_id": case["id"],
+                            "phrase": phrase,
+                            "entity_type": row["entity_type"],
+                            "detected_text": row["text"],
+                        }
+                    )
+
+    return {
+        "schema_version": "1.0",
+        "module": "dutch_care_recognizers",
+        "synthetic_data_only": True,
+        "production_ready": False,
+        "human_review_required": True,
+        "entity_count": len(dedicated_entities),
+        "positive_contract_count": len(ALL_POSITIVE_CASES),
+        "positive_contract_passed": len(ALL_POSITIVE_CASES) - len(positive_failures),
+        "positive_contract_failures": positive_failures,
+        "forbidden_positive_failure_count": len(forbidden_positive_failures),
+        "forbidden_positive_failures": forbidden_positive_failures,
+        "negative_contract_count": len(NEGATIVE_CASES),
+        "negative_contract_passed": len(NEGATIVE_CASES) - len(negative_failures),
+        "negative_contract_failures": negative_failures,
+        "corpus_dedicated_expectation_count": corpus_expected,
+        "corpus_dedicated_found_count": corpus_found,
+        "corpus_dedicated_failures": corpus_failures,
+        "clinical_preserve_overlap_count": len(preserve_overlaps),
+        "clinical_preserve_overlaps": preserve_overlaps,
+        "app_registered": False,
+        "next_workpackage": "SCRUB-WP_RECOGNITION_PROFILE_CONFIGURATION_REFACTOR",
+    }

dutch_care_recognizers.py

@@ -0,0 +1,411 @@
+"""Pure Dutch care recognizers for SolidPrivacy Scrub Zorgfilter v1.
+
+The module implements the frozen care-recognizer contract only. It is not
+registered in the current app yet and contains no Streamlit, network, AI, cloud
+or file-system behavior.
+
+The current application analyses with ``language="en"`` while adding Dutch
+custom recognizers. Therefore these recognizers default to
+``supported_language="en"``.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Iterable, List, Sequence, Tuple
+
+from presidio_analyzer import (
+    AnalysisExplanation,
+    EntityRecognizer,
+    RecognizerResult,
+)
+
+
+DUTCH_CARE_ENTITY_NAMES: tuple[str, ...] = (
+    "NL_PATIENT_NUMBER",
+    "NL_CARE_CLIENT_NUMBER",
+    "NL_MEDICAL_RECORD_NUMBER",
+    "NL_EPD_ECD_NUMBER",
+    "NL_HEALTH_INSURANCE_NUMBER",
+    "NL_REFERRAL_NUMBER",
+    "NL_TREATMENT_REFERENCE",
+    "NL_LAB_SAMPLE_NUMBER",
+    "NL_CARE_INCIDENT_NUMBER",
+    "NL_CARE_INDICATION_REFERENCE",
+    "NL_AGB_CODE",
+    "NL_CARE_PROVIDER_NAME",
+    "NL_CARE_ORGANIZATION",
+    "NL_CARE_LOCATION_REFERENCE",
+    "NL_ROOM_OR_BED_REFERENCE",
+    "NL_CARE_EVENT_DATE",
+)
+
+# Keep name recognition strict and label-bound. Generic PERSON recognition stays
+# in the generic local NER/profile layer.
+UPPER = r"(?-i:[A-ZÀ-ÖØ-Þ])"
+NAME_TOKEN = rf"{UPPER}[A-Za-zÀ-ÖØ-öø-ÿ'’\-]*"
+NAME_PARTICLE = r"(?:van|de|der|den|ten|ter|el|al|la|du|op|aan|bin|ibn)"
+NAME_GAP = r"[ \t]+"
+NAME_VALUE = (
+    rf"{NAME_TOKEN}"
+    rf"(?:(?:{NAME_GAP}{NAME_PARTICLE})?{NAME_GAP}{NAME_TOKEN}){{0,4}}"
+)
+
+DATE_VALUE = r"\d{1,2}[-/.]\d{1,2}[-/.]\d{2,4}|\d{4}[-/.]\d{1,2}[-/.]\d{1,2}"
+# Strong labels make numeric patient identifiers safe to support. Unlabelled
+# numeric strings are deliberately outside this module.
+REFERENCE_VALUE = r"(?:[A-Z0-9]+(?:[-_/][A-Z0-9]+){1,8}|\d{5,16})"
+
+
+class CareRegexCaptureRecognizer(EntityRecognizer):
+    """Return only a named ``value`` capture from bounded care-context regexes."""
+
+    def __init__(
+        self,
+        entity: str,
+        patterns: Sequence[Tuple[str, str]],
+        score: float,
+        context: Iterable[str] | None = None,
+        supported_language: str = "en",
+    ) -> None:
+        super().__init__(
+            supported_entities=[entity],
+            supported_language=supported_language,
+            name=f"{entity}_care_capture_recognizer",
+        )
+        self.entity = entity
+        self.patterns = tuple(
+            (
+                name,
+                re.compile(pattern, flags=re.IGNORECASE | re.MULTILINE),
+            )
+            for name, pattern in patterns
+        )
+        self.score = float(score)
+        self.context = tuple(context or ())
+
+    def load(self) -> None:
+        return None
+
+    def analyze(
+        self,
+        text: str,
+        entities: List[str],
+        nlp_artifacts=None,
+    ) -> List[RecognizerResult]:
+        if entities and self.entity not in entities:
+            return []
+
+        source_text = text or ""
+        results: List[RecognizerResult] = []
+        seen: set[tuple[int, int]] = set()
+
+        for pattern_name, pattern in self.patterns:
+            for match in pattern.finditer(source_text):
+                if "value" not in match.groupdict() or match.group("value") is None:
+                    continue
+                start, end = match.span("value")
+
+                while start < end and source_text[start].isspace():
+                    start += 1
+                while end > start and source_text[end - 1] in " \t\r\n.,;:":
+                    end -= 1
+                if start >= end or (start, end) in seen:
+                    continue
+                seen.add((start, end))
+
+                explanation = AnalysisExplanation(
+                    recognizer=self.name,
+                    original_score=self.score,
+                    pattern_name=pattern_name,
+                    pattern=pattern.pattern,
+                    textual_explanation=(
+                        f"Detected by `{self.name}` using bounded care-context "
+                        f"pattern `{pattern_name}`. Only the named value span is "
+                        "returned so the care label, professional role and clinical "
+                        "meaning remain readable."
+                    ),
+                )
+                results.append(
+                    RecognizerResult(
+                        entity_type=self.entity,
+                        start=start,
+                        end=end,
+                        score=self.score,
+                        analysis_explanation=explanation,
+                        recognition_metadata={
+                            RecognizerResult.RECOGNIZER_NAME_KEY: self.name,
+                            RecognizerResult.RECOGNIZER_IDENTIFIER_KEY: getattr(
+                                self, "id", self.name
+                            ),
+                        },
+                    )
+                )
+
+        return results
+
+
+def _reference_recognizer(
+    entity: str,
+    labels_regex: str,
+    score: float,
+    supported_language: str,
+) -> CareRegexCaptureRecognizer:
+    return CareRegexCaptureRecognizer(
+        entity=entity,
+        patterns=[
+            (
+                f"{entity.lower()}_labelled_value",
+                rf"(?<!\w)(?:{labels_regex})(?!\w)\s*(?:is|:|#|=|-)?\s*"
+                rf"(?P<value>{REFERENCE_VALUE})(?![A-Z0-9_/-])",
+            )
+        ],
+        score=score,
+        context=re.split(r"\|", labels_regex),
+        supported_language=supported_language,
+    )
+
+
+def _provider_recognizer(supported_language: str) -> CareRegexCaptureRecognizer:
+    title = r"(?:(?:dr|dokter)\.?\s+)?"
+    patterns = [
+        (
+            "reporter_with_professional_role",
+            rf"\brapporteur\s*:\s*(?:verpleegkundige|verzorgende(?:\s+IG)?|"
+            rf"persoonlijk\s+begeleider|zorgco[oö]rdinator)\s+{title}"
+            rf"(?P<value>{NAME_VALUE})\b",
+        ),
+        (
+            "reporting_or_transfer_role",
+            rf"\b(?:overdragend\s+verpleegkundige|persoonlijk\s+begeleider|"
+            rf"behandelend\s+(?:internist|arts|specialist)|hoofdbehandelaar|"
+            rf"regiebehandelaar|huisarts|betrokken\s+arts|aanvrager)\s*:\s*"
+            rf"{title}(?P<value>{NAME_VALUE})\b",
+        ),
+        (
+            "prescriber_with_optional_role",
+            rf"\bvoorschrijver\s*:\s*(?:(?:huisarts|arts|specialist|apotheker)\s+)?"
+            rf"{title}(?P<value>{NAME_VALUE})\b",
+        ),
+        (
+            "incident_reporter_with_role",
+            rf"\bmelder\s*:\s*(?:verzorgende(?:\s+IG)?|verpleegkundige|arts|"
+            rf"persoonlijk\s+begeleider)\s+{title}(?P<value>{NAME_VALUE})\b",
+        ),
+    ]
+    return CareRegexCaptureRecognizer(
+        entity="NL_CARE_PROVIDER_NAME",
+        patterns=patterns,
+        score=0.84,
+        context=(
+            "rapporteur",
+            "verpleegkundige",
+            "huisarts",
+            "behandelend arts",
+            "persoonlijk begeleider",
+            "voorschrijver",
+            "melder",
+        ),
+        supported_language=supported_language,
+    )
+
+
+def _organization_recognizer(supported_language: str) -> CareRegexCaptureRecognizer:
+    # Bounded to labelled fields and stopped before sublocation punctuation.
+    organization_value = r"(?-i:[A-ZÀ-ÖØ-Þ])[^,\.\r\n]{1,79}?"
+    patterns = [
+        (
+            "labelled_care_organization",
+            rf"\b(?:zorgorganisatie|ziekenhuis|apotheek|laboratorium|"
+            rf"verzendende\s+organisatie|ontvangende\s+organisatie)\s*:\s*"
+            rf"(?P<value>{organization_value})(?=\s*(?:,|\.|\r?$))",
+        ),
+        (
+            "location_line_primary_organization",
+            rf"\blocatie\s*:\s*(?P<value>{organization_value})"
+            rf"(?=\s*,\s*(?:woonlocatie|locatie|afdeling|team|kamer|bed|appartement)\b)",
+        ),
+        (
+            "location_line_lowercase_care_organization",
+            r"\blocatie\s*:\s*(?P<value>(?:woonzorgcentrum|zorgcentrum|"
+            r"verpleeghuis|ziekenhuis|zorggroep)\s+"
+            r"(?-i:[A-ZÀ-ÖØ-Þ])[^,\.\r\n]{1,60}?)"
+            r"(?=\s*,\s*(?:woonlocatie|locatie|afdeling|team|kamer|bed|appartement)\b)",
+        ),
+        (
+            "labelled_practice_phrase",
+            rf"(?P<value>praktijk\s+(?-i:[A-ZÀ-ÖØ-Þ])[^,\.\r\n]{{1,60}}?)"
+            rf"(?=\s*(?:,|\.|\r?$))",
+        ),
+    ]
+    return CareRegexCaptureRecognizer(
+        entity="NL_CARE_ORGANIZATION",
+        patterns=patterns,
+        score=0.74,
+        context=(
+            "zorgorganisatie",
+            "ziekenhuis",
+            "apotheek",
+            "laboratorium",
+            "praktijk",
+            "verzendende organisatie",
+            "ontvangende organisatie",
+        ),
+        supported_language=supported_language,
+    )
+
+
+def _location_recognizer(supported_language: str) -> CareRegexCaptureRecognizer:
+    patterns = [
+        (
+            "bounded_named_care_location",
+            r"(?P<value>\b(?:woonlocatie|locatie|afdeling|team)\s+"
+            r"(?-i:[A-ZÀ-ÖØ-Þ])[A-Za-zÀ-ÖØ-öø-ÿ0-9'’\-]*"
+            r"(?:[ \t]+[A-Za-zÀ-ÖØ-öø-ÿ0-9'’\-]+){0,4})"
+            r"(?=\s*(?:,|\.|\r?$))",
+        )
+    ]
+    return CareRegexCaptureRecognizer(
+        entity="NL_CARE_LOCATION_REFERENCE",
+        patterns=patterns,
+        score=0.72,
+        context=("woonlocatie", "locatie", "afdeling", "team"),
+        supported_language=supported_language,
+    )
+
+
+def _room_bed_recognizer(supported_language: str) -> CareRegexCaptureRecognizer:
+    return CareRegexCaptureRecognizer(
+        entity="NL_ROOM_OR_BED_REFERENCE",
+        patterns=[
+            (
+                "room_bed_or_apartment_code",
+                r"(?P<value>\b(?:kamer|bed|appartement)\s+"
+                r"(?:[A-Z](?:-[A-Z0-9]+)?|\d{1,4}[A-Z]?|[A-Z]\d{1,4}|"
+                r"[A-Z0-9]+-[A-Z0-9]+))\b",
+            )
+        ],
+        score=0.72,
+        context=("kamer", "bed", "appartement"),
+        supported_language=supported_language,
+    )
+
+
+def _event_date_recognizer(supported_language: str) -> CareRegexCaptureRecognizer:
+    labels = (
+        r"opnamedatum|ontslagdatum|rapportagedatum|evaluatiedatum|incidentdatum|"
+        r"afnamedatum|afspraakdatum|behandeldatum|onderzoeksdatum"
+    )
+    return CareRegexCaptureRecognizer(
+        entity="NL_CARE_EVENT_DATE",
+        patterns=[
+            (
+                "labelled_care_event_date",
+                rf"\b(?:{labels})\s*(?:is|:)?\s*(?P<value>{DATE_VALUE})\b",
+            )
+        ],
+        score=0.82,
+        context=tuple(labels.split("|")),
+        supported_language=supported_language,
+    )
+
+
+def get_dutch_care_entity_names() -> List[str]:
+    """Return the frozen dedicated Zorgfilter v1 entity names."""
+
+    return list(DUTCH_CARE_ENTITY_NAMES)
+
+
+def get_dutch_care_recognizers(
+    supported_language: str = "en",
+) -> List[EntityRecognizer]:
+    """Return pure, context-bound Zorgfilter v1 recognizers.
+
+    The returned recognizers are not automatically registered in the current
+    application. Profile composition is handled in a later workpackage.
+    """
+
+    recognizers: List[EntityRecognizer] = [
+        _reference_recognizer(
+            "NL_PATIENT_NUMBER",
+            r"pati[eë]ntnummer|patientnummer|pati[eë]ntnr\.?|patientnr\. ?",
+            0.91,
+            supported_language,
+        ),
+        _reference_recognizer(
+            "NL_CARE_CLIENT_NUMBER",
+            r"cli[eë]ntnummer|clientnummer|cli[eë]ntnr\.?|clientnr\.?",
+            0.90,
+            supported_language,
+        ),
+        _reference_recognizer(
+            "NL_MEDICAL_RECORD_NUMBER",
+            r"medisch\s+dossiernummer|zorgdossiernummer|medisch\s+dossiernr\. ?",
+            0.90,
+            supported_language,
+        ),
+        _reference_recognizer(
+            "NL_EPD_ECD_NUMBER",
+            r"EPD[-\s]?nummer|ECD[-\s]?nummer|EPD\s*nr\.?|ECD\s*nr\. ?",
+            0.92,
+            supported_language,
+        ),
+        _reference_recognizer(
+            "NL_HEALTH_INSURANCE_NUMBER",
+            r"verzekerdennummer|zorgverzekeringsnummer|verzekerdennr\. ?",
+            0.90,
+            supported_language,
+        ),
+        _reference_recognizer(
+            "NL_REFERRAL_NUMBER",
+            r"verwijsnummer|verwijzingsnummer|verwijsnr\. ?",
+            0.90,
+            supported_language,
+        ),
+        _reference_recognizer(
+            "NL_TREATMENT_REFERENCE",
+            r"behandelnummer|zorgtrajectnummer|receptnummer|behandelnr\.?|trajectnummer",
+            0.88,
+            supported_language,
+        ),
+        _reference_recognizer(
+            "NL_LAB_SAMPLE_NUMBER",
+            r"monsternummer|sample[-\s]?ID|labnummer|laboratoriumnummer|"
+            r"accessienummer|onderzoeks[-\s]?ID",
+            0.90,
+            supported_language,
+        ),
+        _reference_recognizer(
+            "NL_CARE_INCIDENT_NUMBER",
+            r"MIC[-\s]?nummer|MIM[-\s]?nummer|VIM[-\s]?nummer|"
+            r"zorgincidentnummer|incidentnummer|medicatiefoutnummer",
+            0.91,
+            supported_language,
+        ),
+        _reference_recognizer(
+            "NL_CARE_INDICATION_REFERENCE",
+            r"CIZ[-\s]?nummer|Wlz[-\s]?indicatie|Wmo[-\s]?beschikking|"
+            r"zorgtoewijzing|PGB[-\s]?nummer|indicatiebesluit",
+            0.90,
+            supported_language,
+        ),
+        CareRegexCaptureRecognizer(
+            entity="NL_AGB_CODE",
+            patterns=[
+                (
+                    "strong_agb_context_eight_digits",
+                    r"\b(?:AGB[-\s]?(?:code|nummer|nr\.?)|AGB)\s*(?:is|:|#|=|-)?\s*"
+                    r"(?P<value>\d{8})\b",
+                )
+            ],
+            score=0.94,
+            context=("AGB-code", "AGB-nummer", "AGB"),
+            supported_language=supported_language,
+        ),
+        _provider_recognizer(supported_language),
+        _organization_recognizer(supported_language),
+        _location_recognizer(supported_language),
+        _room_bed_recognizer(supported_language),
+        _event_date_recognizer(supported_language),
+    ]
+    return recognizers

handover/workpackages/20260803_1652_care_profile_recognizer_implementation.md

@@ -0,0 +1,61 @@
+# Handover — SCRUB-WP_CARE_PROFILE_RECOGNIZER_IMPLEMENTATION
+
+Repository: solidprivacy-nl/scrub  
+Workpackage title: Zorgfilter v1 recognizer implementation  
+Status: completed; final clean PR validation initiated
+
+## Summary
+
+Implemented the pure `dutch_care_recognizers.py` module against the frozen contract. Sixteen dedicated care entities are recognized through bounded labels and professional context. The module is not registered in the app yet. All 37 positive contracts, 16 negative/collision contracts and 54 dedicated expectations in the eight-document synthetic corpus pass, with zero protected clinical phrase overlaps.
+
+## Files added
+
+- `dutch_care_recognizers.py`
+- `care_recognizer_validation.py`
+- `CARE_RECOGNIZER_IMPLEMENTATION_V1.md`
+- `scripts/generate_care_recognizer_validation.py`
+- `tests/test_dutch_care_recognizers.py`
+- `tests/test_care_recognizer_validation.py`
+- `output/validation/care_recognizer_implementation_validation.json`
+- `workpackage_claims/scrub_wp_care_profile_recognizer_implementation.md`
+- `handover/workpackages/20260803_1652_care_profile_recognizer_implementation.md`
+
+## Files changed
+
+- `ROADMAP.md`
+- `WORKPACKAGES.md`
+- `CHANGELOG.md`
+- `RISK_REGISTER.md`
+
+## Tests
+
+- Frozen public API and sixteen-entity scope.
+- All 37 positive exact-span contracts.
+- All 16 negative, collision and clinical-preservation contracts.
+- Exact Presidio result spans, explanations and metadata.
+- Module-purity import guard.
+- All 54 dedicated care expectations in the eight-document synthetic corpus.
+- Zero overlap with protected clinical passages.
+- Reproducibility of the committed validation artifact.
+
+## Validation
+
+- Initial run #1850 identified five bounded missing context variants; no clinical-overmasking failure.
+- Corrected variants: Dutch `cliëntnummer`, `receptnummer`, generic `incidentnummer`, and lowercase `woonzorgcentrum` after a labeled location field.
+- Corrected GitHub Actions run #1854: 953 tests passed.
+- All temporary operator and workflow files are removed.
+- Final clean GitHub Actions: initiated on this handover commit.
+- Hugging Face sync: not functionally relevant; no current runtime/UI registration changed.
+- App verification: not applicable.
+
+## Remaining risks
+
+- The recognizers are not yet composed into a Zorg profile or registered in the app.
+- Generic PERSON and e-mail remain generic-profile dependencies.
+- Existing BSN and new AGB overlap requires deterministic profile-level precedence validation.
+- Synthetic contract success does not establish production precision or recall.
+- Human review remains mandatory and production readiness remains false.
+
+## Next recommended step
+
+Start `SCRUB-WP_RECOGNITION_PROFILE_CONFIGURATION_REFACTOR` to centralize the four profile definitions and collision/policy composition before changing the visible Streamlit selector.

output/validation/care_recognizer_implementation_validation.json

@@ -0,0 +1,23 @@
+{
+  "schema_version": "1.0",
+  "module": "dutch_care_recognizers",
+  "synthetic_data_only": true,
+  "production_ready": false,
+  "human_review_required": true,
+  "entity_count": 16,
+  "positive_contract_count": 37,
+  "positive_contract_passed": 37,
+  "positive_contract_failures": [],
+  "forbidden_positive_failure_count": 0,
+  "forbidden_positive_failures": [],
+  "negative_contract_count": 16,
+  "negative_contract_passed": 16,
+  "negative_contract_failures": [],
+  "corpus_dedicated_expectation_count": 54,
+  "corpus_dedicated_found_count": 54,
+  "corpus_dedicated_failures": [],
+  "clinical_preserve_overlap_count": 0,
+  "clinical_preserve_overlaps": [],
+  "app_registered": false,
+  "next_workpackage": "SCRUB-WP_RECOGNITION_PROFILE_CONFIGURATION_REFACTOR"
+}

scripts/generate_care_recognizer_validation.py

@@ -0,0 +1,32 @@
+#!/usr/bin/env python3
+"""Generate the machine-readable Zorgfilter recognizer validation report."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+from care_recognizer_validation import build_care_recognizer_validation
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--output",
+        default="output/validation/care_recognizer_implementation_validation.json",
+    )
+    args = parser.parse_args()
+
+    output_path = Path(args.output)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    output_path.write_text(
+        json.dumps(build_care_recognizer_validation(), ensure_ascii=False, indent=2) + "\n",
+        encoding="utf-8",
+    )
+    print(output_path)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

tests/test_care_recognizer_validation.py

@@ -0,0 +1,47 @@
+import json
+from pathlib import Path
+
+from care_recognizer_validation import build_care_recognizer_validation
+
+
+VALIDATION_PATH = Path("output/validation/care_recognizer_implementation_validation.json")
+
+
+def test_care_recognizer_implementation_passes_frozen_contracts():
+    report = build_care_recognizer_validation()
+
+    assert report["schema_version"] == "1.0"
+    assert report["entity_count"] == 16
+    assert report["positive_contract_count"] == 37
+    assert report["positive_contract_passed"] == 37
+    assert report["positive_contract_failures"] == []
+    assert report["forbidden_positive_failure_count"] == 0
+    assert report["forbidden_positive_failures"] == []
+    assert report["negative_contract_count"] == 16
+    assert report["negative_contract_passed"] == 16
+    assert report["negative_contract_failures"] == []
+
+
+def test_care_recognizers_cover_all_dedicated_corpus_expectations():
+    report = build_care_recognizer_validation()
+
+    assert report["corpus_dedicated_expectation_count"] == 54
+    assert report["corpus_dedicated_found_count"] == 54
+    assert report["corpus_dedicated_failures"] == []
+    assert report["clinical_preserve_overlap_count"] == 0
+    assert report["clinical_preserve_overlaps"] == []
+
+
+def test_care_recognizer_validation_keeps_integration_gates_closed():
+    report = build_care_recognizer_validation()
+
+    assert report["synthetic_data_only"] is True
+    assert report["production_ready"] is False
+    assert report["human_review_required"] is True
+    assert report["app_registered"] is False
+    assert report["next_workpackage"] == "SCRUB-WP_RECOGNITION_PROFILE_CONFIGURATION_REFACTOR"
+
+
+def test_committed_care_recognizer_validation_is_reproducible():
+    committed = json.loads(VALIDATION_PATH.read_text(encoding="utf-8"))
+    assert committed == build_care_recognizer_validation()

tests/test_dutch_care_recognizers.py

@@ -0,0 +1,168 @@
+import ast
+import inspect
+from pathlib import Path
+
+from care_recognizer_contracts import (
+    ALL_POSITIVE_CASES,
+    CARE_RECOGNIZER_ENTITY_NAMES,
+    NEGATIVE_CASES,
+)
+from care_test_examples import TEST_CASES
+from dutch_care_recognizers import (
+    CareRegexCaptureRecognizer,
+    get_dutch_care_entity_names,
+    get_dutch_care_recognizers,
+)
+
+
+def _detect(text):
+    entities = get_dutch_care_entity_names()
+    rows = []
+    for recognizer in get_dutch_care_recognizers(supported_language="en"):
+        for result in recognizer.analyze(text, entities=entities, nlp_artifacts=None):
+            rows.append(
+                {
+                    "entity_type": result.entity_type,
+                    "start": result.start,
+                    "end": result.end,
+                    "text": text[result.start:result.end],
+                    "score": result.score,
+                    "recognizer": recognizer.name,
+                }
+            )
+    return sorted(rows, key=lambda row: (row["start"], row["end"], row["entity_type"]))
+
+
+def _exact(rows, entity_type, value):
+    return [
+        row for row in rows
+        if row["entity_type"] == entity_type and row["text"] == value
+    ]
+
+
+def test_public_api_matches_frozen_contract():
+    assert get_dutch_care_entity_names() == list(CARE_RECOGNIZER_ENTITY_NAMES)
+    recognizers = get_dutch_care_recognizers()
+    assert len(recognizers) == len(CARE_RECOGNIZER_ENTITY_NAMES)
+    assert {entity for recognizer in recognizers for entity in recognizer.supported_entities} == set(
+        CARE_RECOGNIZER_ENTITY_NAMES
+    )
+    assert all(recognizer.supported_language == "en" for recognizer in recognizers)
+
+
+def test_all_positive_contracts_return_the_exact_value_span():
+    for case in ALL_POSITIVE_CASES:
+        rows = _detect(case["text"])
+        matches = _exact(rows, case["entity_type"], case["expected_value"])
+        assert len(matches) == 1, (case["id"], rows)
+
+        expected_start = case["text"].index(case["expected_value"])
+        assert matches[0]["start"] == expected_start
+        assert matches[0]["end"] == expected_start + len(case["expected_value"])
+
+        for forbidden_entity in case["forbidden_entities"]:
+            assert not _exact(rows, forbidden_entity, case["expected_value"]), (
+                case["id"],
+                forbidden_entity,
+                rows,
+            )
+
+
+def test_all_negative_contracts_avoid_forbidden_care_entities():
+    for case in NEGATIVE_CASES:
+        rows = _detect(case["text"])
+        forbidden = set(case["forbidden_entities"])
+        violations = [row for row in rows if row["entity_type"] in forbidden]
+        assert violations == [], (case["id"], violations)
+
+
+def test_capture_results_have_explanations_and_stable_metadata():
+    text = "Patiëntnummer: PAT-2026-1148."
+    recognizer = next(
+        recognizer for recognizer in get_dutch_care_recognizers()
+        if recognizer.supported_entities == ["NL_PATIENT_NUMBER"]
+    )
+    results = recognizer.analyze(
+        text,
+        entities=get_dutch_care_entity_names(),
+        nlp_artifacts=None,
+    )
+
+    assert len(results) == 1
+    result = results[0]
+    assert result.entity_type == "NL_PATIENT_NUMBER"
+    assert text[result.start:result.end] == "PAT-2026-1148"
+    assert result.analysis_explanation is not None
+    assert result.recognition_metadata
+
+
+def test_care_module_has_no_streamlit_network_cloud_or_file_write_imports():
+    source_path = Path(inspect.getsourcefile(CareRegexCaptureRecognizer))
+    tree = ast.parse(source_path.read_text(encoding="utf-8"))
+    imported_roots = set()
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            imported_roots.update(alias.name.split(".")[0] for alias in node.names)
+        elif isinstance(node, ast.ImportFrom) and node.module:
+            imported_roots.add(node.module.split(".")[0])
+
+    assert imported_roots.isdisjoint(
+        {
+            "streamlit",
+            "requests",
+            "httpx",
+            "urllib",
+            "openai",
+            "azure",
+            "boto3",
+            "pathlib",
+            "os",
+            "subprocess",
+        }
+    )
+
+
+def test_dedicated_care_expectations_in_full_corpus_are_detected_exactly():
+    dedicated_entities = set(get_dutch_care_entity_names())
+    checked = 0
+    missing = []
+
+    for case in TEST_CASES:
+        rows = _detect(case["text"])
+        for bucket in ("replace", "review_selected"):
+            for expectation in case[bucket]:
+                if expectation["entity_type"] not in dedicated_entities:
+                    continue
+                checked += 1
+                if not _exact(rows, expectation["entity_type"], expectation["value"]):
+                    missing.append(
+                        {
+                            "case_id": case["id"],
+                            "entity_type": expectation["entity_type"],
+                            "value": expectation["value"],
+                            "detected": rows,
+                        }
+                    )
+
+    assert checked > 0
+    assert missing == []
+
+
+def test_full_corpus_clinical_preserve_phrases_do_not_overlap_care_results():
+    overlaps = []
+    for case in TEST_CASES:
+        rows = _detect(case["text"])
+        for phrase in case["preserve"]:
+            phrase_start = case["text"].index(phrase)
+            phrase_end = phrase_start + len(phrase)
+            for row in rows:
+                if phrase_start < row["end"] and row["start"] < phrase_end:
+                    overlaps.append(
+                        {
+                            "case_id": case["id"],
+                            "phrase": phrase,
+                            "row": row,
+                        }
+                    )
+
+    assert overlaps == []

workpackage_claims/scrub_wp_care_profile_recognizer_implementation.md

@@ -0,0 +1,22 @@
+# Workpackage claim — SCRUB-WP_CARE_PROFILE_RECOGNIZER_IMPLEMENTATION
+
+Repository: `solidprivacy-nl/scrub`  
+Claimed at: 2026-08-03 16:42 Europe/Amsterdam  
+Status: completed
+
+## Scope
+
+- Implement the frozen pure `dutch_care_recognizers.py` module.
+- Implement exactly the sixteen dedicated care entities and two public helper functions.
+- Pass the 37 positive exact-span and 16 negative/collision/clinical-preservation contracts.
+- Add implementation validation and a machine-readable result artifact.
+- Do not register the recognizers in the current app yet.
+
+## Boundaries
+
+- Synthetic data only.
+- No Streamlit, network, AI, cloud or file-write behavior in the recognizer module.
+- No current profile selector, threshold or entity-default change.
+- No export, Scrub Key or reinsert semantic change.
+- Generic PERSON and e-mail remain generic-profile responsibilities.
+- Human review remains required and production readiness remains false.