Upload folder using huggingface_hub

README.md

@@ -1,3 +1,262 @@
 ---
-license: mit
+language:
+- ru
+- en
+license: apache-2.0
+base_model: DeepPavlov/rubert-base-cased
+library_name: transformers
+pipeline_tag: token-classification
+tags:
+- ner
+- token-classification
+- pii
+- secret-detection
+- credentials
+- masking
+- russian
+- bert
 ---
+
+# ner_rus_bert-secret_detection
+
+Дообученная голова `BertForTokenClassification` поверх `DeepPavlov/rubert-base-cased`,
+которая размечает в русскоязычном тексте **учётные данные** (логины, пароли,
+токены, ключи), **персональные данные** (ФИО, организации, локации) и **номера
+договоров**. Основной сценарий, под который она обучалась - маскирование
+пользовательских сообщений и фрагментов конфигов перед отправкой во внешнюю LLM.
+
+> **Модель — половина системы.** В проде она работает **в объединении с
+> детерминированным regex-слоем**, и все опубликованные ниже цифры покрытия
+> учётных данных относятся к объединению `NER ∪ regex`. Одна NER заметно слабее
+> по recall — так и задумано: её задача добирать то, что не ловится регулярками
+> (естественная формулировка, кириллица, контекст), не переусердствуя с ложными
+> срабатываниями. Обе половины лежат в этом репозитории: `core/scrubber.py` +
+> `gitleaks.toml`
+> См. [Детерминированный слой](#детерминированный-слой).
+
+## Метки
+
+17 BIO-тегов, 8 типов сущностей:
+
+| Группа | Метки |
+|---|---|
+| Учётные данные | `LOGIN`, `PASSWORD`, `AUTH_TOKEN`, `SECRET_KEY` |
+| ПДн | `PERSON`, `LOCATION`, `ORGANIZATION` |
+| Прочее | `CONTRACT_NUMBER` |
+
+Схема — `B-`/`I-`/`O`, полный список в `config.json` (`id2label`).
+
+## Быстрый старт
+
+Репозиторий приватный: сначала `hf auth login` (или `HF_TOKEN=…` в окружении),
+иначе загрузка по id вернёт 401.
+
+```python
+from transformers import pipeline
+
+ner = pipeline(
+    "token-classification",
+    model="fef2/ner_rus_bert-secret_detection",
+    aggregation_strategy="simple",
+)
+
+text = 'user = svc_billing, password = "Xt7#pQm2Zr", api_key: sk-live-4f9a2b7c1e6d8f3a0b5c9d2e'
+for e in ner(text):
+    print(f"{e['entity_group']:<12} {e['score']:.3f} {text[e['start']:e['end']]!r}")
+```
+
+```
+LOGIN        0.936 'svc_billing'
+PASSWORD     0.993 'Xt7#pQm2Zr'
+SECRET_KEY   0.996 'sk-live-4f9a2b7c1e6d8f3a0b5c9d2e'
+```
+
+Обратите внимание: режьте исходную строку по `start`/`end`, а **не** берите поле
+`word` — pipeline отдаёт его склеенным из wordpiece, с лишними пробелами
+(`'svc _ billing'`).
+
+**У `pipeline()` три ограничения, из-за которых он годится только для проб.**
+Он не режет длинный вход на окна — текст длиннее 512 wordpiece падает с
+`RuntimeError: The size of tensor a (1218) must match the size of tensor b (512)`;
+не нормализует юникод; и это **только NER**, без детерминированного слоя. Для
+настоящей работы возьмите `predict.py` из этого репозитория.
+
+## Правильный путь: `predict.py`
+
+`predict.py` — перенос инференс-логики развёрнутого сервиса целиком:
+NFC-нормализация, нарезка на окна по 384 реальных wordpiece по границам
+предложений, BIO-декод, детерминированный слой, смещения в символах, склейка
+пересекающихся спанов. Нужны только `torch` и `transformers` — regex-половина
+на чистом stdlib.
+
+```bash
+python predict.py --text 'password = "Xt7#pQm2Zr"'      # замаскированный текст
+python predict.py --file документ.txt --spans           # спаны построчно
+cat лог.txt | python predict.py --json                  # спаны в JSON
+cat лог.txt | python predict.py --json --no-rules       # только NER, без regex
+```
+
+```python
+from predict import Detector
+
+det = Detector("fef2/ner_rus_bert-secret_detection", device="cpu")   # cuda / mps
+
+text = ('Коллеги, доступ к стенду: user = svc_billing, password = "Xt7#pQm2Zr", '
+        'api_key: sk-live-4f9a2b7c1e6d8f3a0b5c9d2e. Ответственный — Петров Сергей '
+        'Иванович (ПАО «Сбербанк», Санкт-Петербург), договор № 77-АБ/2025-4412.')
+
+for s in det.spans(text):
+    print(f"{s.start:>4} {s.end:>4}  {s.label:<16} {s.source:<5} {s.text!r}")
+
+print(det.mask(text))
+```
+
+```
+  33   44  LOGIN            ner   'svc_billing'
+  58   68  PASSWORD         both  'Xt7#pQm2Zr'
+  80  112  SECRET_KEY       both  'sk-live-4f9a2b7c1e6d8f3a0b5c9d2e'
+ 130  152  PERSON           ner   'Петров Сергей Иванович'
+ 154  167  ORGANIZATION     ner   'ПАО «Сбербанк'
+ 170  185  LOCATION         ner   'Санкт-Петербург'
+ 198  213  CONTRACT_NUMBER  ner   '77-АБ/2025-4412'
+```
+
+`source` говорит, кто нашёл спан: `ner`, `regex` или `both` (нашли оба —
+самый спокойный случай). У чисто regex-спанов `score` равен `None`: у
+детерминированного правила нет вероятности, и подставлять туда единицу было бы
+враньём.
+
+Документ на 6800 символов режется на 4 окна и размечается целиком — граница окна
+не теряет спаны, потому что нарезка идёт по концам предложений и абзацев.
+
+### Четыре контракта, которые легко нарушить
+
+**Окно — 384 *реальных* wordpiece.** Модель обучалась на окнах такого размера,
+и `plan_windows` закладывает 384 токена **без** учёта `[CLS]`/`[SEP]`, то есть
+`max_length=386` при токенизации. Если считать по-хагингфейсовски — 384 вместе со
+служебными, — в окно попадёт 382 реальных токена, и предсказания на длинных
+текстах разойдутся: два лишних wordpiece меняют каждый контекстный эмбеддинг
+последовательности. На эталонном сплите в этот зазор попадают 280 строк из 6312,
+и 5 из них предсказываются иначе.
+
+**Смещения — по NFC-нормализованному тексту.** `Detector.spans()` сам приводит
+вход к NFC, и `start`/`end` — индексы кодовых точек **нормализованной** строки.
+Для латиницы и обычной кириллицы это то же самое, но текст с составными символами
+(диакритика, вставки из PDF) после нормализации меняет длину, и спаны «поедут».
+Режьте по спанам нормализованную строку:
+
+```python
+import unicodedata
+normalized = unicodedata.normalize("NFC", text)   # ровно то, что видела модель
+fragment = normalized[span.start:span.end]
+```
+
+**Батчи, а не по одному.** Пропускная способность здесь берётся из батчей;
+`Detector(batch_size=...)` задаёт размер микро-батча окон. На CPU замеренная
+скорость NER-половины — около **9.5k токенов/с**; на GPU в FP16 (`fp16=True`,
+включается автоматически при `device="cuda"`) она перестаёт быть узким местом
+задолго до regex-слоя.
+
+**Модель не решает, что делать со спаном.** `mask()` подставляет
+`[REDACTED:LABEL]` — это пример, а не политика. Обратимое маскирование
+(плейсхолдеры с обратной подстановкой), пороги по `score`, отдельная политика на
+`PERSON` против `SECRET_KEY` — всё это ваш слой поверх спанов.
+
+## Детерминированный слой
+
+Рядом с моделью по тому же тексту работает второй, полностью детерминированный
+детектор — `core.scrubber.credential_sites`. Итоговый набор спанов есть
+**объединение** двух источников с последующей склейкой. Он даёт постоянный, не
+зависящий от чекпоинта пол по типовым форматам, а NER добирает то, что регуляркой
+не описывается. Внутри — три детектора:
+
+| Детектор | Что ищет | Метки |
+|---|---|---|
+| `kv` | `ключ = значение` с онтологией ключей (`password`, `пароль`, `api_key`, `токен`, `login`…) | `PASSWORD` `SECRET_KEY` `AUTH_TOKEN` `LOGIN` |
+| `cli` | значения у известных флагов известных команд (`--password=…`, `curl -u user:pass`) | `PASSWORD` `AUTH_TOKEN` |
+| `opaque` | непрозрачные высокоэнтропийные значения + правила gitleaks | `AUTH_TOKEN` `SECRET_KEY` `SECRET` |
+
+Правила gitleaks отбираются по идентификатору (`…token…` → `AUTH_TOKEN`,
+`…key…`/`…secret…` → `SECRET_KEY`), из 222 правил конфига до рантайма доходят
+**168** — остальные отсеиваются фильтром по имени либо не компилируются под
+`re` без предупреждений. `load_gitleaks_rules` возвращает вторым значением
+именно счётчик отброшенных.
+
+`cli` бьёт по таблице «команда → флаг» и отдаёт только само значение пароля или
+токена; логин из `-u user:pass` в объединение не попадает, а голая строка
+подключения (`postgres://user:pass@host`) не покрывается вовсе — это осознанная
+граница релиза, см. [Ограничения](#ограничения).
+
+Слой умеет отличать живое значение от инертного: `${DB_PASSWORD}`,
+`os.environ["TOKEN"]`, `<your-key-here>`, `changeme` и уже проставленные маркеры
+`[REDACTED:…]` он не трогает (`core._shim.is_inert_value`). Спан с меткой
+`SECRET` — это опознанное непрозрачное значение, тип которого установить не
+удалось; в модельный набор из 17 меток он не входит и приходит только отсюда.
+
+Замеренная цена этой половины на тестовом сплите: 2891 срабатывание, из них 452
+не задевают ни одного gold-спана; вычёркивается 3.03 % всех символов, из которых
+0.37 % корпуса лежит вне gold-спанов. Слой чисто питоновский и держит GIL —
+около 0.7 мс на текст (~460k токенов/с на ядро), так что в проде именно он, а не
+GPU, упирается в потолок пропускной способности.
+
+Отключается через `Detector(rules=None)` или `--no-rules` — но тогда цифры ниже
+к вам не относятся.
+
+
+## Обучение
+
+| | |
+|---|---|
+| Базовая модель | `DeepPavlov/rubert-base-cased` (vocab 119547, 12 слоёв, 768) |
+| Шаги / batch / lr | 8000 · 32 · 3e-5, warmup 800, weight decay 0.1, grad clip 1.0, AMP |
+| Окно | 384 wordpiece |
+| Выбор чекпоинта | по `credential_any_f1` на валидации (максимизируется вклад NER в детекцию учётных данных: пол от регулярок постоянен) |
+| Данные | синтетические семейства учётных данных в русскоязычном контексте (kv-pair в сообщениях, конфигах и коде) + replay-доля 0.35 на общий русский NER, чтобы не потерять ПДн |
+
+## Ограничения
+
+* **CLI и DSN — вне зоны ответственности.** Строки подключения
+  (`postgres://user:pass@host`) и пароли в аргументах команд сознательно не входят
+  в целевую поверхность релиза и на ней не измерялись. Модель на них ведёт себя
+  неровно: `psql -U reporter -W 'Qw!7823ml' -h db.corp.ru` → спан `PASSWORD`
+  захватывает открывающую кавычку, а хвост имени хоста уезжает в `LOGIN`.
+  Детерминированный слой подстраховывает только известные флаги известных команд.
+  Целевая поверхность — **kv-pair**: `ключ = значение` в сообщениях, конфигах и
+  коде.
+* **Границы спанов не всегда аккуратны.** Модель может отрезать закрывающую
+  кавычку (`'ПАО «Сбербанк'`) или разделить фразу на два спана. Для маскирования
+  это безопасно (спан всё равно вычёркивается), для извлечения сущностей —
+  учитывайте.
+* **Не детектор «всех секретов».** Формат, не похожий ни на одно из обученных
+  семейств и не покрытый регуляркой, бу��ет пропущен. Recall 0.967 — это про
+  объединение на распределении сплита, а не гарантия на вашем корпусе.
+  Измерьте на своих данных.
+* **Один seed.** Веса выпущены под пилот, из одного прогона; трёхсидовая
+  сертификация релиза не проводилась.
+* **Происхождение данных.** Общая NER-часть (`PERSON`/`ORGANIZATION`/`LOCATION`)
+  опирается на публичные русские NER-корпуса; учётные данные — синтетика.
+  Настоящих секретов в обучающем корпусе нет.
+
+## Файлы
+
+```
+config.json · model.safetensors     веса (BertForTokenClassification, fp32, 709 МБ)
+tokenizer.json · vocab.txt · …      токенизатор (fast, BertTokenizer, cased)
+predict.py                          инференс: окна · NFC · BIO-декод · объединение
+gitleaks.toml                       правила детерминированного слоя
+core/scrubber.py                    детерминированный слой: kv · cli · opaque
+core/_shim.py                       инертные значения, NFC, вспомогательное
+core/slot_ontology.yaml             онтология ключей для kv-детектора
+```
+
+`core/` скопирован без изменений из `masking-service/core` бандла
+`r3-2026-07-22` — того же кода, что крутится в проде; `predict.py` вызывает
+`load_gitleaks_rules` и `credential_sites` из него, а не переписывает их. У
+`scrubber.py` есть ещё и CLI датасетного пайплайна (`python -m core.scrubber`) - к инференсу он отношения не имеет, его можно игнорировать.
+
+## Лицензия
+
+Веса выпущены под Apache 2.0 — вслед за базовой `DeepPavlov/rubert-base-cased`.
+`gitleaks.toml` — производная от конфига правил
+[gitleaks](https://github.com/gitleaks/gitleaks) (MIT), из которого оставлены
+правила категорий token/key/secret.

config.json

@@ -0,0 +1,62 @@
+{
+  "architectures": [
+    "BertForTokenClassification"
+  ],
+  "attention_probs_dropout_prob": 0.1,
+  "classifier_dropout": null,
+  "dtype": "float32",
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.1,
+  "hidden_size": 768,
+  "id2label": {
+    "0": "O",
+    "1": "B-PERSON",
+    "2": "I-PERSON",
+    "3": "B-LOCATION",
+    "4": "I-LOCATION",
+    "5": "B-ORGANIZATION",
+    "6": "I-ORGANIZATION",
+    "7": "B-LOGIN",
+    "8": "I-LOGIN",
+    "9": "B-PASSWORD",
+    "10": "I-PASSWORD",
+    "11": "B-AUTH_TOKEN",
+    "12": "I-AUTH_TOKEN",
+    "13": "B-SECRET_KEY",
+    "14": "I-SECRET_KEY",
+    "15": "B-CONTRACT_NUMBER",
+    "16": "I-CONTRACT_NUMBER"
+  },
+  "initializer_range": 0.02,
+  "intermediate_size": 3072,
+  "label2id": {
+    "B-AUTH_TOKEN": 11,
+    "B-CONTRACT_NUMBER": 15,
+    "B-LOCATION": 3,
+    "B-LOGIN": 7,
+    "B-ORGANIZATION": 5,
+    "B-PASSWORD": 9,
+    "B-PERSON": 1,
+    "B-SECRET_KEY": 13,
+    "I-AUTH_TOKEN": 12,
+    "I-CONTRACT_NUMBER": 16,
+    "I-LOCATION": 4,
+    "I-LOGIN": 8,
+    "I-ORGANIZATION": 6,
+    "I-PASSWORD": 10,
+    "I-PERSON": 2,
+    "I-SECRET_KEY": 14,
+    "O": 0
+  },
+  "layer_norm_eps": 1e-12,
+  "max_position_embeddings": 512,
+  "model_type": "bert",
+  "num_attention_heads": 12,
+  "num_hidden_layers": 12,
+  "pad_token_id": 0,
+  "position_embedding_type": "absolute",
+  "transformers_version": "4.57.6",
+  "type_vocab_size": 2,
+  "use_cache": true,
+  "vocab_size": 119547
+}

core/_shim.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import random
+import re
+import unicodedata
+from pathlib import Path
+from typing import Any, Iterable, Iterator
+
+
+SLOT_RE = re.compile(r"⟦SLOT:([A-Z_]+):(\d+)⟧")
+PLACEHOLDER_RE = re.compile(
+    r"^(?:\$\{[^}]+\}|<[^>]+>|YOUR[_-]?[A-Z_]+|changeme|example|placeholder|replace(?:-me)?|)$",
+    re.I,
+)
+REFERENCE_RE = re.compile(
+    r"^(?:[A-Za-z_]\w*|\$\{[^}]+\}|os\.environ\[[^]]+\]|[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)+)$"
+)
+LIVE_PREFIX_RE = re.compile(r"^(?:gh[opsru]_|xox[baprs]-|sk-|AKIA|AIza|glpat-|eyJ)", re.I)
+INTERPOLATION_RE = re.compile(r"^(?:[#$%]?\{[\w.\[\]'\"|-]{1,64}\}|%\([\w.-]{1,64}\)[a-z])$")
+CALL_RE = re.compile(r"^[A-Za-z_$][\w$.]*\([^()]{0,80}\)?$")
+INDEX_RE = re.compile(r"^[A-Za-z_$][\w$.]*\[[\w\"'.-]{0,64}\]?$")
+MARKER_VALUE_RE = re.compile(r"^\[(?:PII_)?REDACTED(?::[A-Z_]+)?\]$")
+
+
+def is_inert_value(value: str, quoted: bool = False) -> bool:
+    if not value or not any(character.isalnum() for character in value):
+        return True
+    if PLACEHOLDER_RE.match(value) or MARKER_VALUE_RE.match(value) or SLOT_RE.search(value) or INTERPOLATION_RE.match(value):
+        return True
+    if LIVE_PREFIX_RE.match(value):
+        return False
+    if quoted:
+        return False
+    return bool(REFERENCE_RE.match(value) or CALL_RE.match(value) or INDEX_RE.match(value) or value.startswith(("//", "http://", "https://", "{", ":")))
+
+
+def nfc(value: str) -> str:
+    return unicodedata.normalize("NFC", value)
+
+
+def stable_id(*parts: object, length: int = 20) -> str:
+    return hashlib.sha256("\0".join(map(str, parts)).encode()).hexdigest()[:length]
+
+
+def seeded_rng(seed: int, *namespace: object) -> random.Random:
+    return random.Random(int(stable_id(seed, *namespace), 16))
+
+
+def read_jsonl(path: Path) -> Iterator[dict[str, Any]]:
+    if not path.exists():
+        return
+    with path.open(encoding="utf-8") as stream:
+        for line_number, line in enumerate(stream, 1):
+            if line.strip():
+                try:
+                    yield json.loads(line)
+                except json.JSONDecodeError as exc:
+                    raise ValueError(f"invalid JSONL in {path}:{line_number}") from exc
+
+
+def write_jsonl(path: Path, rows: Iterable[dict[str, Any]]) -> int:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    count = 0
+    with path.open("w", encoding="utf-8", newline="\n") as stream:
+        for row in rows:
+            stream.write(json.dumps(row, ensure_ascii=False, sort_keys=True, separators=(",", ":")))
+            stream.write("\n")
+            count += 1
+    return count
+
+
+def write_report(staging: Path, name: str, **counts: object) -> None:
+    report = staging / "reports" / f"{name}.json"
+    report.parent.mkdir(parents=True, exist_ok=True)
+    report.write_text(json.dumps(counts, ensure_ascii=False, sort_keys=True, indent=2) + "\n", encoding="utf-8")
+
+
+def add_common_args(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--staging", type=Path, default=Path("staging"))

core/scrubber.py

@@ -0,0 +1,751 @@
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import multiprocessing
+import os
+import re
+import sys
+import warnings
+from collections import Counter
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Literal
+
+from ._shim import LIVE_PREFIX_RE, PLACEHOLDER_RE, REFERENCE_RE, SLOT_RE, add_common_args, is_inert_value, nfc, read_jsonl, seeded_rng, stable_id, write_jsonl, write_report
+
+MARKER_RE = re.compile(r"\[REDACTED:([A-Z_]+)\]")
+KV_RE = re.compile(r"(?im)(?P<key>[A-Za-zА-Яа-яЁё][\w.\-/ ]{0,64}?)[\"']?\s*(?P<sep>[:=])\s*(?:(?P<quote>[\"'])(?P<quoted_value>[^\n\"']*)(?P=quote)|[«“](?P<smart_value>[^\n»”]*)[»”]|(?P<bare_value>[^\s,;&\]\}\n]+))")
+EMAIL_RE = re.compile(r"\b[A-Za-z0-9._%+\-]+@[A-Za-z0-9.\-]+\.[A-Za-z]{2,}\b")
+PHONE_RE = re.compile(r"(?<!\w)(?:\+7|8)[\s(\-]*\d{3}[\s)\-]*\d{3}[\s\-]*\d{2}[\s\-]*\d{2}(?!\w)")
+INN_RE = re.compile(r"(?iu)\b(?:инн|inn)\D{0,12}(\d{10}(?:\d{2})?)")
+SNILS_RE = re.compile(r"(?<!\d)\d{3}-\d{3}-\d{3}\s?\d{2}(?!\d)")
+CARD_RE = re.compile(r"(?<!\d)(?:\d[ -]?){15}\d(?!\d)")
+PASSPORT_RE = re.compile(r"(?iu)\b(?:паспорт|passport)\D{0,12}(\d{4}\s?\d{6})")
+CONTRACT_RE = re.compile(r"(?iu)\b(?:договор|контракт|соглашени[ея])\s*(?:№|N[oо.]?)?\s*([A-ZА-Я0-9][A-ZА-Я0-9\-/]{7,})")
+OPAQUE_RE = re.compile(r"(?<![A-Za-z0-9+/=_-])[A-Za-z0-9+/=_-]{16,}(?![A-Za-z0-9+/=_-])")
+GitleaksRule = "tuple[re.Pattern[str], str | None, tuple[str, ...], int, float]"
+
+_ONTOLOGY_PATH = Path(__file__).with_name("slot_ontology.yaml")
+_ONTOLOGY = json.loads(_ONTOLOGY_PATH.read_text(encoding="utf-8"))
+MARKER_LABELS = {"PASSWORD": "PASSWORD", "TOKEN": "AUTH_TOKEN", "AUTH_TOKEN": "AUTH_TOKEN", "API_KEY": "SECRET_KEY", "SECRET": "SECRET_KEY", "KEY": "SECRET_KEY", "LOGIN": "LOGIN", "USERNAME": "LOGIN", "USER": "LOGIN", "CONTRACT": "CONTRACT_NUMBER"}
+_PROJECT_PII_RECOGNIZERS: list[object] | None = None
+SCRUBBER_POLICY_VERSION = "cli-credentials-v2"
+
+
+@dataclass(frozen=True)
+class CredentialSite:
+    start: int
+    end: int
+    label: str
+    detector: str
+    disposition: str
+
+
+@dataclass(frozen=True)
+class CliCredentialFlag:
+    commands: frozenset[str] | None
+    mode: Literal["userinfo", "password", "token"]
+    attached: bool = False
+
+
+def _entropy(value: str) -> float:
+    frequencies = Counter(value)
+    return -sum((count / len(value)) * math.log2(count / len(value)) for count in frequencies.values()) if value else 0.0
+
+
+def _key_parts(key: str) -> tuple[str, list[str]]:
+    camel = re.sub(r"(?<=[a-zа-яё])(?=[A-ZА-ЯЁ])", "_", key)
+    camel = re.sub(r"(?<=[A-ZА-ЯЁ])(?=[A-ZА-ЯЁ][a-zа-яё])", "_", camel)
+    normalized = re.sub(r"[\s.\-/]+", "_", camel.lower()).strip("_")
+    return normalized, [part for part in normalized.split("_") if part]
+
+
+_FILE_EXT_RE = re.compile(r"\.(?:md|mdx|go|js|mjs|cjs|ts|tsx|jsx|py|sh|rb|rs|java|kt|cs|cpp|cc|c|h|hpp|yml|yaml|json|toml|txt|cfg|conf|ini|env|html|css|scss|sql|log|xml|lock)(?:$|[-:]\d)", re.I)
+
+
+def classify_key(key: str) -> str | None:
+    if "/" in key or _FILE_EXT_RE.search(key.strip()):
+        return None
+    normalized, parts = _key_parts(key)
+    if normalized in set(_ONTOLOGY["stop"]) or any(part in set(_ONTOLOGY["stop"]) for part in parts):
+        return None
+    for label, names in _ONTOLOGY["exact"].items():
+        if normalized in names:
+            return label
+    for label, segments in _ONTOLOGY["strong"].items():
+        if any(part in segments for part in parts):
+            return label
+    for label, weak in _ONTOLOGY["weak"].items():
+        for segment, qualifiers in weak.items():
+            if segment not in parts:
+                continue
+            if not qualifiers or any(part in qualifiers for part in parts):
+                return label
+    return None
+
+
+def _is_live_opaque(value: str) -> bool:
+    compact = value.strip("\"'«»“”")
+    return len(compact) >= 16 and any(character.isdigit() for character in compact) and re.fullmatch(r"[A-Za-z0-9+/=_-]+", compact) is not None and _entropy(compact) >= 3.5
+
+
+def _format_preserving(value: str, *, seed: int, record_key: str, offset: int) -> str:
+    rng = seeded_rng(seed, record_key, offset)
+    if value.isdigit():
+        return "".join(rng.choice("0123456789") for _ in value)
+    if re.fullmatch(r"[0-9A-Fa-f]+", value):
+        alphabet = "0123456789ABCDEF" if value.upper() == value else "0123456789abcdef"
+        return "".join(rng.choice(alphabet) for _ in value)
+    replacement = []
+    for character in value:
+        if character.isdigit():
+            replacement.append(rng.choice("0123456789"))
+        elif character.isupper():
+            replacement.append(rng.choice("ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
+        elif character.islower():
+            replacement.append(rng.choice("abcdefghijklmnopqrstuvwxyz"))
+        else:
+            replacement.append(character)
+    return "".join(replacement)
+
+
+_LITERAL_ESCAPE_RE = re.compile(r"\\+[nrt]")
+_STRIP_CHARS = "\"'«»“”\\()"
+
+
+def _kv_value(match: re.Match[str]) -> tuple[int, int, str, bool]:
+    for group, quoted in (("quoted_value", True), ("smart_value", True), ("bare_value", False)):
+        if match.group(group) is not None:
+            start, end = match.span(group)
+            value = match.group(group)
+            if not quoted:
+                cut = _LITERAL_ESCAPE_RE.search(value)
+                if cut and cut.start() > 0:
+                    value = value[:cut.start()]; end = start + len(value)
+                text = match.string
+                opened = value.count("{") - value.count("}") + value.count("[") - value.count("]")
+                while opened > 0 and end < len(text) and text[end] in "}]":
+                    value += text[end]; end += 1; opened -= 1
+            return start, end, value, quoted
+    raise AssertionError("K/V regex produced no value")
+
+
+def _kv_core(start: int, end: int, value: str) -> tuple[int, int, str, bool]:
+    core = value.strip(_STRIP_CHARS)
+    lead = value.find(core) if core else 0
+    opening, closing = value[:lead], value[lead + len(core):]
+    quotes = "\"'«»“”"
+    wrapped = any(character in quotes for character in opening) and any(character in quotes for character in closing)
+    return start + lead, start + lead + len(core), core, wrapped
+
+
+def _kv_matches(text: str):
+    tokens = [match.span() for match in SLOT_RE.finditer(text)]
+    position = 0
+    while True:
+        match = KV_RE.search(text, position)
+        if match is None:
+            return
+        key_start = match.start("key")
+        enclosing = next((span for span in tokens if span[0] <= key_start < span[1]), None)
+        if enclosing:
+            position = enclosing[1]
+            continue
+        yield match
+        position = match.end("key")
+
+
+def _overlaps(start: int, end: int, replacements: list[tuple[int, int, str]]) -> bool:
+    return any(not (end <= left or start >= right) for left, right, _ in replacements)
+
+
+def _replace(text: str, replacements: list[tuple[int, int, str]]) -> str:
+    for start, end, replacement in sorted(replacements, reverse=True):
+        text = text[:start] + replacement + text[end:]
+    return text
+
+
+def _merge_ranges(ranges: list[list[int]]) -> list[list[int]]:
+    merged: list[list[int]] = []
+    for start, end in sorted(ranges):
+        if merged and start <= merged[-1][1]:
+            merged[-1][1] = max(merged[-1][1], end)
+        else:
+            merged.append([start, end])
+    return merged
+
+
+def sanitize_synthetic_text(text: str, covered_ranges: list[list[int]], *, seed: int, record_key: str, rules: list[GitleaksRule], max_rounds: int = 64) -> tuple[str, list[list[int]], int, int]:
+    covered = _merge_ranges([list(item) for item in covered_ranges]); added: list[list[int]] = []; replaced_count = 0; rounds = 0
+    for _iteration in range(max_rounds):
+        pending: list[tuple[int, int, str]] = []
+
+        def add_uncovered(start: int, end: int) -> None:
+            pieces = [(start, end)]
+            for covered_start, covered_end in covered:
+                remainder = []
+                for piece_start, piece_end in pieces:
+                    if piece_end <= covered_start or piece_start >= covered_end:
+                        remainder.append((piece_start, piece_end))
+                    else:
+                        if piece_start < covered_start:
+                            remainder.append((piece_start, covered_start))
+                        if covered_end < piece_end:
+                            remainder.append((covered_end, piece_end))
+                pieces = remainder
+            for piece_start, piece_end in pieces:
+                if piece_start >= piece_end or SLOT_RE.search(text[piece_start:piece_end]) or _overlaps(piece_start, piece_end, pending):
+                    continue
+                pending.append((piece_start, piece_end, _format_preserving(text[piece_start:piece_end], seed=seed, record_key=record_key, offset=piece_start)))
+
+        for site in credential_sites(text, rules):
+            if site.disposition != "quarantine":
+                add_uncovered(site.start, site.end)
+        if not pending:
+            break
+        text = _replace(text, pending)
+        fresh = [[start, end] for start, end, _replacement in pending]
+        added.extend(fresh); covered = _merge_ranges([*covered, *fresh])
+        replaced_count += len(pending); rounds += 1
+    return text, _merge_ranges(added), replaced_count, rounds
+
+
+_CREDENTIAL_ENTITIES = frozenset({"PASSWORD", "LOGIN", "JWT", "BEARER_TOKEN", "API_KEY", "PRIVATE_KEY", "DB_URL"})
+
+
+def _pii_recognizers() -> list:
+    global _PROJECT_PII_RECOGNIZERS
+    if _PROJECT_PII_RECOGNIZERS is None:
+        try:
+            candidates = (Path(__file__).resolve().parents[2] / "presidio", Path("/app"))
+            for directory in candidates:
+                if (directory / "recognizers").is_dir() and str(directory) not in sys.path:
+                    sys.path.insert(0, str(directory))
+            from recognizers import ALL_RECOGNIZERS
+            selected = []
+            for factory in ALL_RECOGNIZERS:
+                recognizer = factory()
+                supported = set(getattr(recognizer, "supported_entities", []) or [])
+                if supported and supported.isdisjoint(_CREDENTIAL_ENTITIES):
+                    selected.append(recognizer)
+            _PROJECT_PII_RECOGNIZERS = selected
+        except Exception:
+            _PROJECT_PII_RECOGNIZERS = []
+    return _PROJECT_PII_RECOGNIZERS
+
+
+def pii_recognizer_names() -> list[str]:
+    return sorted(type(recognizer).__name__ for recognizer in _pii_recognizers())
+
+
+def _project_pii_matches(text: str) -> list[tuple[int, int]]:
+    matches = []
+    for recognizer in _pii_recognizers():
+        try:
+            matches.extend((result.start, result.end) for result in recognizer.analyze(text, entities=None, nlp_artifacts=None))
+        except Exception:
+            continue
+    return matches
+
+
+def load_gitleaks_rules(path: Path | None) -> tuple[list[GitleaksRule], int]:
+    if path is None or not path.exists():
+        return [], 0
+    try:
+        import tomllib
+        raw_rules = tomllib.loads(path.read_text(encoding="utf-8")).get("rules", [])
+    except ImportError:
+        raw_rules = []
+        for block in path.read_text(encoding="utf-8").split("[[rules]]")[1:]:
+            identifier = re.search(r'^id\s*=\s*"([^"]+)"', block, re.M)
+            regex = re.search(r"^regex\s*=\s*'''(.*?)'''", block, re.M | re.S)
+            if identifier and regex:
+                keywords = re.search(r"^keywords\s*=\s*\[(.*?)\]", block, re.M | re.S)
+                secret_group = re.search(r"^secretGroup\s*=\s*(\d+)", block, re.M)
+                entropy = re.search(r"^entropy\s*=\s*([\d.]+)", block, re.M)
+                raw_rules.append({"id": identifier.group(1), "regex": regex.group(1), "keywords": re.findall(r'"([^"]+)"', keywords.group(1)) if keywords else [], "secretGroup": int(secret_group.group(1)) if secret_group else None, "entropy": float(entropy.group(1)) if entropy else None})
+    rules = []; skipped = 0
+    for rule in raw_rules:
+        identifier = str(rule.get("id", "")).lower(); regex = rule.get("regex")
+        if not isinstance(regex, str):
+            continue
+        label = "AUTH_TOKEN" if "token" in identifier else "SECRET_KEY" if "key" in identifier or "secret" in identifier else None
+        if label is None:
+            continue
+        try:
+            keywords = tuple(str(item).lower() for item in rule.get("keywords", []) if isinstance(item, str))
+            with warnings.catch_warnings():
+                warnings.simplefilter("error", DeprecationWarning)
+                warnings.simplefilter("error", FutureWarning)
+                pattern = re.compile(regex)
+            group = int(rule.get("secretGroup") or (1 if pattern.groups else 0))
+            rules.append((pattern, label, keywords, min(group, pattern.groups), float(rule.get("entropy") or 0.0)))
+        except (re.error, DeprecationWarning, FutureWarning):
+            skipped += 1
+    return rules, skipped
+
+
+def _value_allowed(label: str, value: str, quoted: bool) -> bool:
+    value = value.strip()
+    if value.isdigit() and label != "PASSWORD":
+        return False
+    if label == "LOGIN":
+        return bool(re.fullmatch(r"[\w.@][\w.@\-]{2,63}", value))
+    return 4 <= len(value) <= 256 and (quoted or not any(character.isspace() for character in value))
+
+
+def detector_core(text: str, start: int, end: int) -> tuple[int, int]:
+    value = text[start:end]
+    if "=" in value:
+        prefix, suffix = value.split("=", 1)
+        if suffix and re.fullmatch(r"[?&]?[A-Za-zА-Яа-яЁё_][\w.-]{0,64}", prefix):
+            start += len(prefix) + 1
+    while start < end and text[start] in "/?&":
+        start += 1
+    while end > start and text[end - 1] in ".,;)]}":
+        end -= 1
+    return start, end
+
+
+def _kv_site(match: re.Match[str], text: str) -> tuple[int, int, str, str | None, str | None]:
+    start, end, value, quoted = _kv_value(match)
+    start, end, value, wrapped = _kv_core(start, end, value); quoted = quoted or wrapped
+    label = classify_key(match.group("key"))
+    if not label or value.startswith("[PII_REDACTED"):
+        return start, end, value, None, None
+    if PLACEHOLDER_RE.match(value):
+        return start, end, value, None, "placeholder"
+    if is_inert_value(value, quoted):
+        return start, end, value, None, "code_reference"
+    if not _value_allowed(label, value, quoted) or _looks_like_user_sentence(match, text, end, quoted):
+        return start, end, value, None, None
+    start, end = detector_core(text, start, end)
+    value = text[start:end]
+    if not value:
+        return start, end, value, None, "empty_core"
+    return start, end, value, label, None
+
+
+def kv_credential_sites(text: str) -> list[tuple[int, int, str, str]]:
+    sites = []
+    for match in _kv_matches(text):
+        start, end, value, label, _reason = _kv_site(match, text)
+        if label:
+            sites.append((start, end, value, label))
+    return sites
+
+
+_CLI_CREDENTIAL_FLAGS = {
+    "-u": CliCredentialFlag(frozenset({"curl"}), "userinfo", True), "--user": CliCredentialFlag(frozenset({"curl"}), "userinfo"),
+    "-U": CliCredentialFlag(frozenset({"curl"}), "userinfo", True), "--proxy-user": CliCredentialFlag(frozenset({"curl"}), "userinfo"),
+    "--oauth2-bearer": CliCredentialFlag(frozenset({"curl"}), "token"),
+    "--password": CliCredentialFlag(None, "password"), "--passwd": CliCredentialFlag(None, "password"), "--pass": CliCredentialFlag(None, "password"),
+    "--http-password": CliCredentialFlag(frozenset({"wget"}), "password"), "--proxy-password": CliCredentialFlag(frozenset({"wget"}), "password"), "--ftp-password": CliCredentialFlag(frozenset({"wget"}), "password"),
+    "--auth": CliCredentialFlag(frozenset({"http", "https"}), "userinfo"), "-a": CliCredentialFlag(frozenset({"http", "https"}), "userinfo", True),
+    "-p": CliCredentialFlag(frozenset({"mysql"}), "password", True),
+}
+_CLI_FLAG_RE = re.compile(r"(?<![\w=-])(--[A-Za-z][\w-]*|-[A-Za-z])")
+_CLI_REFERENCE_RE = re.compile(r"^(?:\$\w+|\$\{[A-Za-z_]\w*\}|%\w+%|\$\([^)]*\)|`[^`]*`)$")
+_CLI_WRAPPERS = frozenset({"sudo", "env", "command", "xargs"})
+
+
+def _cli_read_value(text: str, position: int) -> tuple[int, int, str] | None:
+    if position >= len(text):
+        return None
+    if text[position] in "\"'":
+        closing = text.find(text[position], position + 1)
+        if closing == -1:
+            return None
+        return position + 1, closing, text[position + 1:closing]
+    match = _CLI_VALUE_RE.match(text, position)
+    if not match:
+        return None
+    start, end = match.start(), match.end()
+    while end > start:
+        char = text[end - 1]
+        if char in "\"',;":
+            end -= 1
+        elif char in ")]}" and {")": "(", "]": "[", "}": "{"}[char] not in text[start:end - 1]:
+            end -= 1
+        else:
+            break
+    return (start, end, text[start:end]) if end > start else None
+
+
+def _cli_part_kind(part: str) -> str:
+    part = part.strip().strip("\"'")
+    if not part:
+        return "empty"
+    if re.fullmatch(r"\$\{[A-Za-z_]\w*:-\}", part):
+        return "empty"
+    if re.fullmatch(r"\$\{[A-Za-z_]\w*:-.+\}", part):
+        return "dynamic_with_literal_fallback"
+    if _CLI_REFERENCE_RE.match(part) or PLACEHOLDER_RE.match(part) or is_inert_value(part, quoted=True):
+        return "reference"
+    return "literal"
+
+
+def _cli_read_shell_value(text: str, position: int) -> tuple[int, int, str, str] | None:
+    if position >= len(text) or text[position].isspace(): return None
+    start = position; quote = None; escaped = backtick = saw_escape = False; parens = braces = 0
+    while position < len(text):
+        char = text[position]
+        if escaped: escaped = False; position += 1; continue
+        if char == "\\": escaped = saw_escape = True; position += 1; continue
+        if quote:
+            if char == quote: quote = None
+            position += 1; continue
+        if backtick:
+            if char == "`": backtick = False
+            position += 1; continue
+        if char in "\"'": quote = char; position += 1; continue
+        if char == "`": backtick = True; position += 1; continue
+        if text.startswith("$(", position): parens += 1; position += 2; continue
+        if text.startswith("${", position): braces += 1; position += 2; continue
+        if char == ")" and parens: parens -= 1; position += 1; continue
+        if char == "}" and braces: braces -= 1; position += 1; continue
+        if char.isspace() and not parens and not braces: break
+        position += 1
+    end = position
+    malformed = any((quote, escaped, backtick, parens, braces, saw_escape))
+    wrapped = end - start >= 2 and text[start] in "\"'" and text[end - 1] == text[start]
+    if wrapped:
+        start += 1; end -= 1
+    elif not malformed:
+        while end > start and text[end - 1] in "\"',;": end -= 1
+    value = text[start:end]
+    if not value: return None
+    kind = "ambiguous" if malformed else _cli_part_kind(value)
+    if not malformed and (value.startswith("$(") or value.startswith("${") or value.startswith("`")):
+        kind = "reference"
+    return start, end, value, kind
+
+
+def _cli_command(text: str, position: int) -> str | None:
+    segment = re.split(r"(?:;|&&|\|\| |\|)", text[:position])[-1]
+    embedded = re.findall(r"(?:^|[\s\"'])((?:curl|wget|mysql|http|https))(?:\.exe)?(?=$|[\s\"'])", segment, re.I)
+    if embedded:
+        return embedded[-1].lower()
+    for word in re.findall(r"(?:[^\s'\"]+|'[^']*'|\"[^\"]*\")+", segment):
+        token = re.sub(r"\.exe$", "", word.strip("'\"").rsplit("/", 1)[-1].lower())
+        if token in _CLI_WRAPPERS or token.startswith("-") or re.fullmatch(r"[A-Za-z_]\w*=.*", token): continue
+        return token
+    return None
+
+
+def _cli_credential_parts(text: str):
+    for flag_match in _CLI_FLAG_RE.finditer(text):
+        flag = flag_match.group(1)
+        config = _CLI_CREDENTIAL_FLAGS.get(flag)
+        if config is None:
+            continue
+        command = _cli_command(text, flag_match.start())
+        if config.commands is not None and command not in config.commands:
+            continue
+        after = flag_match.end()
+        if after < len(text) and text[after] == "=":
+            read = _cli_read_shell_value(text, after + 1)
+        elif config.attached and after < len(text) and not text[after].isspace():
+            read = _cli_read_shell_value(text, after)
+        else:
+            cursor = after
+            while cursor < len(text) and text[cursor] in " \t":
+                cursor += 1
+            read = _cli_read_shell_value(text, cursor) if cursor > after or (after < len(text) and text[after].isspace()) else None
+        if read is None:
+            continue
+        value_start, value_end, value, value_kind = read
+        part = {"password": None, "username": None}
+        if config.mode == "userinfo":
+            colon = value.find(":")
+            if colon == -1:
+                continue
+            username = value[:colon]
+            part["username"] = (value_start, value_start + colon, username, "LOGIN", _cli_part_kind(username))
+            password_kind = value_kind if value_kind in {"ambiguous", "dynamic_with_literal_fallback"} else _cli_part_kind(value[colon + 1:])
+            part["password"] = (value_start + colon + 1, value_end, value[colon + 1:], "PASSWORD", password_kind)
+        else:
+            part["password"] = (value_start, value_end, value, "AUTH_TOKEN" if config.mode == "token" else "PASSWORD", value_kind)
+        yield part
+
+
+def cli_credential_sites(text: str) -> list[tuple[int, int, str, str, str]]:
+    sites: list[tuple[int, int, str, str, str]] = []
+    for part in _cli_credential_parts(text):
+        password = part["password"]
+        if password and password[4] != "empty":
+            sites.append(password)
+    return sites
+
+
+def cli_credential_slots(text: str) -> list[tuple[int, int, str, str]]:
+    slots: list[tuple[int, int, str, str]] = []
+    for part in _cli_credential_parts(text):
+        password = part["password"]
+        if not password or password[4] != "literal":
+            continue
+        username = part["username"]
+        if username and username[4] == "literal":
+            slots.append((username[0], username[1], "LOGIN", "cli"))
+        slots.append((password[0], password[1], password[3], "cli"))
+    return slots
+
+
+def credential_sites(text: str, rules: list[GitleaksRule]) -> list[CredentialSite]:
+    sites = [CredentialSite(start, end, label, "kv", "slot") for start, end, _value, label in kv_credential_sites(text)]
+    sites += [CredentialSite(start, end, label, "cli", "slot" if kind == "literal" else "quarantine") for start, end, _value, label, kind in cli_credential_sites(text) if kind in {"literal", "ambiguous", "dynamic_with_literal_fallback"}]
+    sites += [CredentialSite(start, end, label or "SECRET", "opaque", "replace") for start, end, label, _match_start, _match_end in _find_live(text, rules)]
+    return sorted(set(sites), key=lambda item: (item.start, item.end, item.label, item.detector))
+
+
+def _looks_like_user_sentence(match: re.Match[str], text: str, value_end: int, quoted: bool) -> bool:
+    key = match.group("key")
+    _, parts = _key_parts(key)
+    if quoted:
+        return False
+    remainder = text[value_end:text.find("\n", value_end) if text.find("\n", value_end) != -1 else len(text)]
+    continues_as_sentence = bool(re.match(r"\s+[\wА-Яа-яЁё]{2,}", remainder))
+    return continues_as_sentence and (
+        "user" in parts or
+        (match.group("sep") == ":" and " " in key and len(parts) >= 3)
+    )
+
+
+def _find_live(text: str, rules: list[GitleaksRule]) -> list[tuple[int, int, str | None, int, int]]:
+    found = []
+    for match in OPAQUE_RE.finditer(text):
+        if not _is_live_opaque(match.group()):
+            continue
+        start, end, value, label = match.start(), match.end(), match.group(), None
+        if "=" in value:
+            prefix, suffix = value.split("=", 1)
+            classified = classify_key(prefix)
+            if classified and suffix:
+                start += len(prefix) + 1; value = suffix; label = classified
+        found.append((start, end, label, match.start(), match.end()))
+    lowered = text.lower()
+    for pattern, label, keywords, group, entropy in rules:
+        if keywords and not any(keyword in lowered for keyword in keywords):
+            continue
+        for match in pattern.finditer(text):
+            start, end = match.span(group)
+            if start < 0 or end <= start:
+                start, end = match.span()
+            if entropy and _entropy(text[start:end]) < entropy:
+                continue
+            found.append((start, end, label, match.start(), match.end()))
+    normalized = []
+    for start, end, label, match_start, match_end in found:
+        start, end = detector_core(text, start, end)
+        if start < end:
+            normalized.append((start, end, label, match_start, match_end))
+    return sorted(set(normalized), key=lambda item: (item[0], item[1], item[2] or ""))
+
+
+def scrub_row(raw: dict, slot_counter: int, *, seed: int = 42, gitleaks_rules: list[GitleaksRule] | None = None) -> tuple[dict | None, list[dict], dict[str, int], int]:
+    text = nfc(str(raw.get("content", raw.get("text", ""))))
+    record_key = str(raw.get("group_id") or raw.get("conversation_id") or raw.get("session_id") or stable_id(text))
+    counts: Counter[str] = Counter(); slots: list[dict] = []; flags = list(raw.get("flags", [])); negative_reason = raw.get("negative_reason")
+    pii_replacements: list[tuple[int, int, str]] = []
+    for pattern in (EMAIL_RE, PHONE_RE, SNILS_RE, CARD_RE, PASSPORT_RE, INN_RE):
+        for match in pattern.finditer(text):
+            start, end = match.span(1) if pattern in {INN_RE, PASSPORT_RE} else match.span()
+            if not _overlaps(start, end, pii_replacements):
+                pii_replacements.append((start, end, "[PII_REDACTED]")); counts["pii_replaced"] += 1
+    for start, end in _project_pii_matches(text):
+        if not _overlaps(start, end, pii_replacements):
+            pii_replacements.append((start, end, "[PII_REDACTED]")); counts["pii_replaced"] += 1
+    text = _replace(text, pii_replacements)
+    if pii_replacements:
+        flags.append("pii_replaced")
+    replacements: list[tuple[int, int, str]] = []; entropy_replacements: list[tuple[int, int, str]] = []
+
+    def add_slot(start: int, end: int, label: str, slot_type: str) -> None:
+        nonlocal slot_counter
+        if _overlaps(start, end, replacements):
+            return
+        token = f"⟦SLOT:{label}:{slot_counter}⟧"; slot_counter += 1
+        replacements.append((start, end, token))
+        slots.append({"slot_id": token, "record_key": record_key, "klass": label, "injection_slot_type": slot_type})
+        counts["slots"] += 1
+
+    for marker in MARKER_RE.finditer(text):
+        kind = marker.group(1); label = MARKER_LABELS.get(kind) or classify_key(kind)
+        if kind == "ENV":
+            context = text[max(0, marker.start() - 120):marker.end() + 120]
+            key_match = re.search(r"([\w.-]+)\s*[:=]\s*\[REDACTED:ENV\]", context, re.I)
+            label = classify_key(key_match.group(1)) if key_match else None
+        if label:
+            add_slot(marker.start(), marker.end(), label, "redacted_marker")
+    cli_quarantine_ranges = [(site.start, site.end) for site in credential_sites(text, gitleaks_rules or []) if site.detector == "cli" and site.disposition == "quarantine"]
+    for match in _kv_matches(text):
+        start, end, _value, label, reason = _kv_site(match, text)
+        if any(not (end <= left or start >= right) for left, right in cli_quarantine_ranges):
+            continue
+        if reason:
+            negative_reason = negative_reason or reason; counts[reason] += 1; continue
+        if label:
+            add_slot(start, end, label, "dsn" if "://" in text[max(0, match.start() - 50):match.end() + 50] else "kv_pair")
+    for match in CONTRACT_RE.finditer(text):
+        if not _overlaps(match.start(1), match.end(1), replacements):
+            add_slot(match.start(1), match.end(1), "CONTRACT_NUMBER", "kv_pair")
+    for start, end, label, slot_type in cli_credential_slots(text):
+        add_slot(start, end, label, slot_type)
+
+    for start, end, _label, _match_start, _match_end in _find_live(text, gitleaks_rules or []):
+        if _overlaps(start, end, replacements):
+            overlapping = sorted((left, right) for left, right, _ in replacements if left < end and right > start)
+            leftovers = []; cursor = start
+            for left, right in overlapping:
+                if left > cursor:
+                    leftovers.append((cursor, left))
+                cursor = max(cursor, right)
+            if cursor < end:
+                leftovers.append((cursor, end))
+            if any(_is_live_opaque(text[piece_start:piece_end]) for piece_start, piece_end in leftovers):
+                counts["quarantined_conflict"] += 1
+                return None, [], dict(counts), slot_counter
+            continue
+        replacement = _format_preserving(text[start:end], seed=seed, record_key=record_key, offset=start)
+        item = (start, end, replacement); replacements.append(item); entropy_replacements.append(item); counts["entropy_replaced_values"] += 1
+    safe_text = _replace(text, replacements)
+    final_ranges = []; delta = 0
+    entropy_starts = {(start, end, replacement) for start, end, replacement in entropy_replacements}
+    for start, end, replacement in sorted(replacements):
+        final_start = start + delta; final_end = final_start + len(replacement)
+        if (start, end, replacement) in entropy_starts:
+            final_ranges.append([final_start, final_end])
+        delta += len(replacement) - (end - start)
+    final_ranges = _merge_ranges(final_ranges)
+    if entropy_replacements:
+        flags.append("entropy_replaced")
+    for _iteration in range(64):
+        pending: list[tuple[int, int, str]] = []
+
+        def add_post_replacement(start: int, end: int) -> None:
+            pieces = [(start, end)]
+            for covered_start, covered_end in final_ranges:
+                remainder = []
+                for piece_start, piece_end in pieces:
+                    if piece_end <= covered_start or piece_start >= covered_end:
+                        remainder.append((piece_start, piece_end))
+                    else:
+                        if piece_start < covered_start:
+                            remainder.append((piece_start, covered_start))
+                        if covered_end < piece_end:
+                            remainder.append((covered_end, piece_end))
+                pieces = remainder
+            for piece_start, piece_end in pieces:
+                if piece_start >= piece_end or SLOT_RE.search(safe_text[piece_start:piece_end]) or _overlaps(piece_start, piece_end, pending):
+                    continue
+                pending.append((piece_start, piece_end, _format_preserving(safe_text[piece_start:piece_end], seed=seed, record_key=record_key, offset=piece_start)))
+
+        for site in credential_sites(safe_text, gitleaks_rules or []):
+            if site.disposition != "quarantine":
+                add_post_replacement(site.start, site.end)
+        if not pending:
+            break
+        safe_text = _replace(safe_text, pending)
+        final_ranges = _merge_ranges([*final_ranges, *[[start, end] for start, end, _replacement in pending]])
+        counts["postscan_replaced_values"] += len(pending)
+        counts["postscan_rounds"] += 1
+        if "entropy_replaced" not in flags:
+            flags.append("entropy_replaced")
+    slot_spans = [list(match.span()) for match in SLOT_RE.finditer(safe_text)]
+    covered = _merge_ranges([*final_ranges, *slot_spans])
+    for site in credential_sites(safe_text, gitleaks_rules or []):
+        if site.detector == "cli" and site.disposition == "quarantine" and not any(left <= site.start and site.end <= right for left, right in covered):
+            counts["cli_credential_quarantine"] += 1
+            return None, [], dict(counts), slot_counter
+    row = dict(raw); row.pop("content", None); row["text"] = safe_text; row["flags"] = sorted(set(flags)); row["negative_reason"] = negative_reason; row["entropy_replaced_ranges"] = final_ranges
+    return row, slots, dict(counts), slot_counter
+
+
+def unresolved_live_values(row: dict, rules: list[GitleaksRule]) -> int:
+    ranges = _merge_ranges([list(item) for item in row.get("entropy_replaced_ranges", [])])
+    slots = [match.span() for match in SLOT_RE.finditer(row["text"])]
+    def covered(start: int, end: int) -> bool:
+        return any(left <= start and end <= right for left, right in [*ranges, *slots])
+    return sum(not covered(site.start, site.end) for site in credential_sites(row["text"], rules))
+
+
+_SLOT_BASE_STRIDE = 65536
+_WORKER_RULES: list[GitleaksRule] = []
+
+
+def _init_worker(config: str) -> None:
+    global _WORKER_RULES
+    _WORKER_RULES = load_gitleaks_rules(Path(config))[0] if config else []
+
+
+def _scrub_chunk(payload: tuple[int, int, list[str]]) -> tuple[list[str], list[dict], dict[str, int]]:
+    seed, start_index, lines = payload
+    out_rows: list[str] = []; out_slots: list[dict] = []; counts: Counter[str] = Counter()
+    for offset, line in enumerate(lines):
+        raw = json.loads(line); counts["input"] += 1
+        safe, found, row_counts, _ = scrub_row(raw, (start_index + offset) * _SLOT_BASE_STRIDE, seed=seed, gitleaks_rules=_WORKER_RULES)
+        counts.update(row_counts)
+        if safe is None:
+            counts["quarantined"] += 1
+        else:
+            counts["safe"] += 1; out_rows.append(json.dumps(safe, ensure_ascii=False, sort_keys=True, separators=(",", ":"))); out_slots.extend(found)
+    return out_rows, out_slots, dict(counts)
+
+
+def _unresolved_chunk(lines: list[str]) -> int:
+    return sum(unresolved_live_values(json.loads(line), _WORKER_RULES) for line in lines)
+
+
+def _line_chunks(paths: list[Path], size: int):
+    index = 0; buffer: list[str] = []
+    for path in paths:
+        with path.open(encoding="utf-8") as stream:
+            for line in stream:
+                if not line.strip():
+                    continue
+                buffer.append(line)
+                if len(buffer) >= size:
+                    yield index, buffer; index += len(buffer); buffer = []
+    if buffer:
+        yield index, buffer
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__); parser.add_argument("--input", type=Path, action="append", help="turns JSONL; defaults to both extract outputs"); parser.add_argument("--gitleaks-config", type=Path, default=Path("../dataset/gitleaks/config/gitleaks.toml")); parser.add_argument("--workers", type=int, default=max(1, (os.cpu_count() or 2) - 2)); parser.add_argument("--verify-only", action="store_true", help="re-scan the existing scrubbed_turns.jsonl without rewriting it"); parser.add_argument("--allow-missing-pii-recognizers", action="store_true", help="proceed without personal-data recognizers; the output is then NOT safe to export"); add_common_args(parser); args = parser.parse_args()
+    inputs = args.input or [args.staging / "codechat_turns.jsonl", args.staging / "swechat_turns.jsonl"]
+    recognizers = pii_recognizer_names()
+    if not recognizers and not args.allow_missing_pii_recognizers:
+        raise SystemExit("PII recognizers unavailable (is presidio_analyzer installed?); "
+                         "re-run inside the pipeline image or pass --allow-missing-pii-recognizers")
+    rules, skipped_rules = load_gitleaks_rules(args.gitleaks_config); slots: list[dict] = []; counts: Counter[str] = Counter()
+    config = str(args.gitleaks_config) if args.gitleaks_config and Path(args.gitleaks_config).exists() else ""
+    pool = multiprocessing.get_context("spawn").Pool(args.workers, initializer=_init_worker, initargs=(config,))
+    scrubbed_path = args.staging / "scrubbed_turns.jsonl"; scrubbed_path.parent.mkdir(parents=True, exist_ok=True)
+    if args.verify_only:
+        report_path = args.staging / "quarantine_report.json"
+        report = json.loads(report_path.read_text(encoding="utf-8")) if report_path.is_file() else {}
+        if report.get("scrubber_policy_version") != SCRUBBER_POLICY_VERSION:
+            raise SystemExit("staging was not produced by the current scrubber policy")
+        with pool:
+            unresolved = sum(pool.imap_unordered(_unresolved_chunk, (lines for _, lines in _line_chunks([scrubbed_path], 2000))))
+        print(json.dumps({"unresolved_live_values": unresolved, "workers": args.workers}, sort_keys=True))
+        raise SystemExit(1 if unresolved else 0)
+    with pool, scrubbed_path.open("w", encoding="utf-8", newline="\n") as out:
+        payloads = ((args.seed, index, lines) for index, lines in _line_chunks(inputs, 2000))
+        for out_rows, out_slots, chunk_counts in pool.imap(_scrub_chunk, payloads):
+            counts.update(chunk_counts); slots.extend(out_slots)
+            for line in out_rows:
+                out.write(line + "\n")
+        write_jsonl(args.staging / "slots.jsonl", slots)
+        out.flush()
+        unresolved = sum(pool.imap_unordered(_unresolved_chunk, (lines for _, lines in _line_chunks([scrubbed_path], 2000))))
+    report = {"scrubber_policy_version": SCRUBBER_POLICY_VERSION, "input": counts["input"], "safe": counts["safe"], "quarantined": counts["quarantined"], "unresolved_live_values": unresolved, "gitleaks_rules": len(rules), "gitleaks_rules_skipped": skipped_rules, "workers": args.workers, "pii_recognizers": recognizers, "by_type": dict(sorted(counts.items()))}
+    (args.staging / "quarantine_report.json").write_text(json.dumps(report, ensure_ascii=False, sort_keys=True, indent=2) + "\n", encoding="utf-8"); write_report(args.staging, "scrubber", **report); print(json.dumps(report, ensure_ascii=False, sort_keys=True))
+    if unresolved:
+        raise SystemExit(1)
+
+
+if __name__ == "__main__":
+    main()

core/slot_ontology.yaml

@@ -0,0 +1,20 @@
+{
+  "exact": {
+    "PASSWORD": ["db_password", "password", "passwd", "pwd", "пароль"],
+    "SECRET_KEY": ["client_secret", "api_key", "private_key", "signing_key", "encryption_key"],
+    "AUTH_TOKEN": ["access_token", "refresh_token", "auth_token", "id_token", "токен"],
+    "LOGIN": ["login", "username", "user_name", "логин"]
+  },
+  "strong": {
+    "PASSWORD": ["password", "passwd", "pwd", "пароль"],
+    "SECRET_KEY": ["secret"],
+    "AUTH_TOKEN": ["bearer", "jwt"]
+  },
+  "weak": {
+    "SECRET_KEY": {"key": ["api", "client", "secret", "access", "private", "signing", "encryption"]},
+    "AUTH_TOKEN": {"token": []},
+    "LOGIN": {"user": [], "login": []}
+  },
+  "stop": ["tokenizer", "max_tokens", "input_tokens", "output_tokens", "tokens_used", "token_count", "user_agent", "useragent", "keyboard", "keyword", "keywords", "monkey", "turkey", "bypass", "passenger", "passage",
+           "expiry", "expires", "expiration", "ttl", "timeout", "time", "hours", "days", "minutes", "seconds", "port", "limit", "duration", "interval", "lifetime", "count", "size", "length"]
+}

model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6a2c875d02398554ec69384f489a0bf4fe3505fc347c6cdd3385d4fd31ef21a4
+size 709127044

predict.py

@@ -0,0 +1,274 @@
+import argparse
+import bisect
+import json
+import re
+import sys
+import unicodedata
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Callable, List, Optional, Sequence, Tuple
+
+_HERE = Path(__file__).resolve().parent
+if str(_HERE) not in sys.path:          # чтобы `core/` нашёлся из любого cwd
+    sys.path.insert(0, str(_HERE))
+
+WINDOW_WORDPIECES = 384
+DEFAULT_RULES = _HERE / "gitleaks.toml"
+_BOUNDARY_RE = re.compile(r"(?:\n+|[.!?]\s+)")
+
+
+@dataclass(frozen=True)
+class Span:
+    start: int
+    end: int
+    label: str
+    source: str            # ner | regex | both
+    score: Optional[float]  # None у спанов детерминированного слоя
+    text: str
+
+
+def plan_windows(
+    text: str, count: Callable[[str], int], maximum: int = WINDOW_WORDPIECES
+) -> List[Tuple[int, int]]:
+    """Режет текст на куски не длиннее `maximum` wordpiece, по границам
+    предложений и абзацев там, где это возможно. Возвращает пары (начало, конец)
+    в символах."""
+    if not text:
+        return []
+    if count(text) <= maximum:
+        return [(0, len(text))]
+
+    boundaries = sorted({0, *(m.end() for m in _BOUNDARY_RE.finditer(text)), len(text)})
+
+    def fitting_end(left: int) -> int:
+        low, step = left, maximum * 4
+        high = min(len(text), left + step)
+        while high < len(text) and count(text[left:high]) <= maximum:
+            low, step = high, step * 2
+            high = min(len(text), left + step)
+        if high == len(text) and count(text[left:high]) <= maximum:
+            return high
+        while low + 1 < high:
+            middle = (low + high) // 2
+            if count(text[left:middle]) <= maximum:
+                low = middle
+            else:
+                high = middle
+        return low
+
+    windows: List[Tuple[int, int]] = []
+    start = 0
+    while start < len(text):
+        candidate = fitting_end(start)
+        if candidate <= start:
+            raise RuntimeError(f"ни один непустой префикс не влезает в {maximum} wordpiece на {start}")
+        boundary = boundaries[bisect.bisect_right(boundaries, candidate) - 1]
+        end = boundary if boundary > start else candidate
+        if count(text[start:end]) > maximum:
+            end = candidate
+        windows.append((start, end))
+        if end >= len(text):
+            break
+        start = end
+    return windows
+
+
+def extract_entities(bio: Sequence[str]) -> List[Tuple[int, int, str]]:
+    """BIO-теги → (начало, конец, метка) в индексах токенов. I- без своего B-
+    открывает сущность: модель не обязана быть согласованной, а терять
+    предсказание из-за этого нельзя."""
+    ents: List[Tuple[int, int, str]] = []
+    cur_label: Optional[str] = None
+    cur_start = 0
+    for i, tag in enumerate(list(bio) + ["O"]):
+        if tag.startswith("B-"):
+            if cur_label is not None:
+                ents.append((cur_start, i, cur_label))
+            cur_label, cur_start = tag[2:], i
+        elif tag.startswith("I-"):
+            label = tag[2:]
+            if cur_label == label:
+                continue
+            if cur_label is not None:
+                ents.append((cur_start, i, cur_label))
+            cur_label, cur_start = label, i
+        else:
+            if cur_label is not None:
+                ents.append((cur_start, i, cur_label))
+            cur_label = None
+    return ents
+
+
+def _lower_score(left: Optional[float], right: Optional[float]) -> Optional[float]:
+    present = [s for s in (left, right) if s is not None]
+    return min(present) if present else None
+
+
+def merge(spans: List[Span], text: str) -> List[Span]:
+    """Склеивает пересекающиеся и примыкающие однометочные спаны. Метку задаёт
+    первый спан — самый левый, затем самый длинный, затем NER вперёд regex."""
+    if not spans:
+        return []
+    ordered = sorted(
+        spans,
+        key=lambda s: (s.start, -(s.end - s.start), 0 if s.source == "ner" else 1),
+    )
+    out: List[Span] = [ordered[0]]
+    for sp in ordered[1:]:
+        prev = out[-1]
+        if sp.start < prev.end or (sp.start == prev.end and sp.label == prev.label):
+            end = max(prev.end, sp.end)
+            out[-1] = Span(
+                prev.start, end, prev.label,
+                prev.source if sp.source == prev.source else "both",
+                prev.score if sp.start < prev.end else _lower_score(prev.score, sp.score),
+                text[prev.start:end],
+            )
+        else:
+            out.append(sp)
+    return out
+
+
+class Detector:
+    def __init__(
+        self,
+        model_id: str = "fef2/ner_rus_bert-secret_detection",
+        device: str = "cpu",
+        fp16: Optional[bool] = None,
+        window_wordpieces: int = WINDOW_WORDPIECES,
+        batch_size: int = 32,
+        rules: Optional[str | Path] = DEFAULT_RULES,
+    ) -> None:
+        import torch
+        from transformers import AutoModelForTokenClassification, AutoTokenizer
+
+        self.torch = torch
+        self.device = device
+        self.window = window_wordpieces
+        self.max_length = window_wordpieces + 2  # [CLS] … [SEP]
+        self.batch_size = max(1, batch_size)
+
+        self.tokenizer = AutoTokenizer.from_pretrained(model_id, use_fast=True)
+        if not self.tokenizer.is_fast:
+            raise SystemExit("нужен fast-токенизатор: без offset_mapping смещения не восстановить")
+
+        model = AutoModelForTokenClassification.from_pretrained(model_id).eval()
+        if fp16 is None:
+            fp16 = device.startswith("cuda")
+        if fp16:
+            model = model.half()
+        self.model = model.to(device)
+        self.id2label = {int(k): v for k, v in model.config.id2label.items()}
+
+        self.rules: list = []
+        if rules is not None:
+            from core.scrubber import load_gitleaks_rules
+
+            self.rules, skipped = load_gitleaks_rules(Path(rules))
+            if not self.rules:
+                raise SystemExit(f"правила не загрузились: {rules}")
+            self.rules_skipped = skipped
+
+    def _count(self, text: str) -> int:
+        return len(self.tokenizer(text, add_special_tokens=False)["input_ids"])
+
+    def spans(self, text: str) -> List[Span]:
+        """Спаны по NFC-нормализованному тексту. Нормализуйте вход тем же NFC,
+        прежде чем резать его по этим индексам."""
+        text = unicodedata.normalize("NFC", text)
+        found: List[Span] = []
+        windows = plan_windows(text, self._count, self.window)
+        for i in range(0, len(windows), self.batch_size):
+            found.extend(self._forward(text, windows[i:i + self.batch_size]))
+        found.extend(self.regex_spans(text))
+        return merge(found, text)
+
+    def regex_spans(self, text: str) -> List[Span]:
+        """Детерминированный слой: kv-детектор, CLI-детектор и правила gitleaks
+        по непрозрачным значениям. Без модели, без GPU."""
+        if not self.rules:
+            return []
+        from core.scrubber import credential_sites
+
+        return [Span(s.start, s.end, s.label, "regex", None, text[s.start:s.end])
+                for s in credential_sites(text, self.rules)]
+
+    def _forward(self, text: str, windows: Sequence[Tuple[int, int]]) -> List[Span]:
+        torch = self.torch
+        enc = self.tokenizer(
+            [text[a:b] for a, b in windows],
+            return_offsets_mapping=True,
+            return_special_tokens_mask=True,
+            truncation=True,
+            max_length=self.max_length,
+            padding=True,
+            return_tensors="pt",
+        )
+        with torch.inference_mode():
+            logits = self.model(
+                input_ids=enc["input_ids"].to(self.device),
+                attention_mask=enc["attention_mask"].to(self.device),
+            ).logits
+        preds = logits.argmax(-1).cpu()
+        confidence = logits.float().softmax(-1).max(-1).values.cpu()
+        offsets = enc["offset_mapping"].tolist()
+        special = enc["special_tokens_mask"].tolist()
+
+        out: List[Span] = []
+        for bi, (base, _) in enumerate(windows):
+            real = [i for i, m in enumerate(special[bi]) if m == 0]
+            bio = [self.id2label[int(preds[bi, i])] for i in real]
+            for begin, end, label in extract_entities(bio):
+                start = base + offsets[bi][real[begin]][0]
+                stop = base + offsets[bi][real[end - 1]][1]
+                if stop > start:
+                    score = min(float(confidence[bi, real[i]]) for i in range(begin, end))
+                    out.append(Span(start, stop, label, "ner", round(score, 4), text[start:stop]))
+        return out
+
+    def mask(self, text: str, template: str = "[REDACTED:{label}]") -> str:
+        text = unicodedata.normalize("NFC", text)
+        parts, cursor = [], 0
+        for sp in self.spans(text):
+            parts.append(text[cursor:sp.start])
+            parts.append(template.format(label=sp.label))
+            cursor = sp.end
+        parts.append(text[cursor:])
+        return "".join(parts)
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    src = ap.add_mutually_exclusive_group()
+    src.add_argument("--text", help="текст прямо в аргументе")
+    src.add_argument("--file", help="файл с текстом (иначе — stdin)")
+    ap.add_argument("--model", default="fef2/ner_rus_bert-secret_detection",
+                    help="id на Hub или локальный каталог")
+    ap.add_argument("--device", default="cpu", help="cpu | cuda | cuda:0 | mps")
+    ap.add_argument("--rules", default=str(DEFAULT_RULES), help="путь к gitleaks.toml")
+    ap.add_argument("--no-rules", action="store_true", help="только NER, без детерминированного слоя")
+    ap.add_argument("--json", action="store_true", help="спаны в JSON")
+    ap.add_argument("--spans", action="store_true", help="спаны построчно")
+    args = ap.parse_args()
+
+    if args.text is not None:
+        text = args.text
+    elif args.file:
+        text = open(args.file, encoding="utf-8").read()
+    else:
+        text = sys.stdin.read()
+
+    det = Detector(args.model, device=args.device, rules=None if args.no_rules else args.rules)
+    if args.json:
+        print(json.dumps([asdict(s) for s in det.spans(text)], ensure_ascii=False, indent=2))
+    elif args.spans:
+        for s in det.spans(text):
+            score = "  ----" if s.score is None else f"{s.score:.4f}"
+            print(f"{s.start:>7} {s.end:>7}  {s.label:<16} {s.source:<5} {score}  {s.text!r}")
+    else:
+        print(det.mask(text))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

special_tokens_map.json

@@ -0,0 +1,7 @@
+{
+  "cls_token": "[CLS]",
+  "mask_token": "[MASK]",
+  "pad_token": "[PAD]",
+  "sep_token": "[SEP]",
+  "unk_token": "[UNK]"
+}

tokenizer_config.json

@@ -0,0 +1,15 @@
+{
+  "clean_up_tokenization_spaces": true,
+  "cls_token": "[CLS]",
+  "do_basic_tokenize": true,
+  "do_lower_case": false,
+  "mask_token": "[MASK]",
+  "model_max_length": 1000000000000000019884624838656,
+  "never_split": null,
+  "pad_token": "[PAD]",
+  "sep_token": "[SEP]",
+  "strip_accents": null,
+  "tokenize_chinese_chars": true,
+  "tokenizer_class": "BertTokenizer",
+  "unk_token": "[UNK]"
+}