code e5cb5ca

code/e5cb5ca/src/aggregate_summaries.py

@@ -0,0 +1,124 @@
+"""シャードごとの shard_summary.json を集約し、全件の件数・母数・内訳を出す。
+
+ローカルのディレクトリ（``--root``）か、HF データセット（``--repo`` と ``--prefix``、
+``outputs/**/shard_summary.json`` を取得）を入力にできる。``--expected-inputs`` に
+入力データセット名を渡すと、入力シャード一覧と突き合わせて未処理シャードを列挙する。
+
+    uv run python abeja-cc-ja/src/aggregate_summaries.py --repo Podtech/abeja-cc-ja-cleaned --prefix outputs \\
+        --expected-inputs Podtech/abeja-cc-ja-filtered --output dataset_summary.json
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+from collections import Counter, defaultdict
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+
+def _load_local(root: Path) -> list[dict[str, Any]]:
+    return [json.loads(p.read_text(encoding="utf-8")) for p in sorted(root.rglob("shard_summary.json"))]
+
+
+def _load_repo(repo_id: str, prefix: str) -> list[dict[str, Any]]:
+    from huggingface_hub import snapshot_download
+
+    local = snapshot_download(repo_id, repo_type="dataset", allow_patterns=[f"{prefix.strip('/')}/**/shard_summary.json"])
+    return _load_local(Path(local) / prefix.strip("/"))
+
+
+def _expected_shards(repo_id: str) -> set[str]:
+    from huggingface_hub import HfApi
+
+    return {Path(p).stem for p in HfApi().list_repo_files(repo_id, repo_type="dataset") if p.endswith(".parquet")}
+
+
+def aggregate(summaries: list[dict[str, Any]]) -> dict[str, Any]:
+    total = Counter()
+    by_reason = Counter()
+    by_category_match = Counter()
+    by_category_deleted = Counter()
+    by_source_matched = Counter()
+    by_source_deleted = Counter()
+    by_rule = Counter()
+    pii_records = Counter()
+    pii_replacements = Counter()
+    seconds = Counter()
+    policies = Counter()
+    versions = Counter()
+    shards = []
+    for s in summaries:
+        shards.append(s["shard"])
+        versions[s.get("pipeline_version", "?")] += 1
+        total["input_rows"] += s["input_rows"]
+        total["toxic_deleted"] += s["toxic"]["records_deleted"]
+        total["toxic_retained"] += s["toxic"]["records_retained"]
+        total["pii_records_with_replacement"] += s["pii"]["records_with_replacement"]
+        total["pii_total_replacements"] += s["pii"]["total_replacements"]
+        total["final_rows"] += s["output"]["final_rows"]
+        for k, v in s["toxic"]["records_deleted_by_reason"].items():
+            by_reason[k] += v
+        for c, v in s["toxic"]["by_category"].items():
+            by_category_match[c] += v["records_with_match"]
+            by_category_deleted[c] += v["records_deleted"]
+        for name, v in (s["toxic"].get("domain_blocklist_by_source") or {}).items():
+            by_source_matched[name] += v.get("records_matched", 0)
+            by_source_deleted[name] += v.get("records_deleted", 0)
+        for name, v in (s["toxic"].get("cooccurrence_by_rule") or {}).items():
+            by_rule[name] += v.get("records_matched", 0)
+        for t, v in s["pii"]["by_type"].items():
+            pii_records[t] += v["records_with_match"]
+            pii_replacements[t] += v["replacement_count"]
+        for k, v in s["seconds"].items():
+            seconds[k] += v
+        p = s["pii"].get("policy") or {}
+        policies[f"{p.get('action')}|{p.get('approved_by')}|{p.get('approved_on')}|{p.get('status')}"] += 1
+    n = total["input_rows"] or 1
+    return {
+        "aggregated_at_utc": datetime.now(timezone.utc).isoformat(),
+        "shards": len(shards),
+        "pipeline_versions": dict(versions),
+        "totals": dict(total),
+        "toxic": {
+            "deletion_rate": round(total["toxic_deleted"] / n, 5),
+            "records_deleted_by_reason": dict(by_reason),
+            "by_category": {c: {"records_with_match": by_category_match[c], "records_deleted": by_category_deleted[c]} for c in sorted(set(by_category_match) | set(by_category_deleted))},
+            "domain_blocklist_by_source": {k: {"records_matched": by_source_matched[k], "records_deleted": by_source_deleted[k]} for k in sorted(by_source_matched)},
+            "cooccurrence_by_rule": dict(by_rule),
+        },
+        "pii": {
+            "denominator_records": total["toxic_retained"],
+            "records_with_replacement_rate": round(total["pii_records_with_replacement"] / max(1, total["toxic_retained"]), 5),
+            "by_type": {t: {"records_with_match": pii_records[t], "replacement_count": pii_replacements[t]} for t in sorted(pii_records)},
+            "policies": dict(policies),
+        },
+        "seconds": dict(seconds),
+        "shard_list": sorted(shards),
+    }
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    source = parser.add_mutually_exclusive_group(required=True)
+    source.add_argument("--root", type=Path)
+    source.add_argument("--repo")
+    parser.add_argument("--prefix", default="outputs")
+    parser.add_argument("--expected-inputs", default=None, help="入力データセット（未処理シャードの検出用）")
+    parser.add_argument("--output", type=Path, required=True)
+    args = parser.parse_args(argv)
+    summaries = _load_local(args.root) if args.root else _load_repo(args.repo, args.prefix)
+    result = aggregate(summaries)
+    if args.expected_inputs:
+        expected = _expected_shards(args.expected_inputs)
+        done = set(result["shard_list"])
+        result["completeness"] = {"expected": len(expected), "done": len(done & expected), "missing": sorted(expected - done)[:200], "missing_count": len(expected - done), "unexpected": sorted(done - expected)[:50]}
+    args.output.write_text(json.dumps(result, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+    t = result["totals"]
+    print(json.dumps({"shards": result["shards"], "input_rows": t.get("input_rows"), "toxic_deleted": t.get("toxic_deleted"), "final_rows": t.get("final_rows"),
+                      "pii_replacements": t.get("pii_total_replacements"), "completeness": result.get("completeness", {}).get("missing_count")}, ensure_ascii=False))
+
+
+if __name__ == "__main__":
+    main()

code/e5cb5ca/src/audit_report.py

@@ -0,0 +1,239 @@
+"""監査項目B（有害・倫理的に問題のあるコンテンツ、項目5〜10）の報告書を生成する。
+
+有害フィルタの出力（summary.json, removed.jsonl, cooccurrence_review.jsonl）と、
+あれば分類器の出力（classify_qwen3guard.py）、目視集計（review_tally.py）を
+統合し、項目ごとに「適用した手法」「検出・除外件数」「例3件」「適用リスト」を
+Markdown にまとめる。手法が1つしか適用されていない項目は「実施」と表示しない。
+
+    uv run python abeja-cc-ja/src/audit_report.py --output-root <toxic出力> \
+        [--classified review/classified.jsonl] [--review-tally review/review_tally.json] \
+        --output audit_report.md
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+from collections import Counter, defaultdict
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+from textmatch import normalize
+
+
+# 監査項目と、フィルタ内部のカテゴリ・規則・ブロックリストの対応。
+AUDIT_ITEMS: list[dict[str, Any]] = [
+    {"item": 5, "title": "性的・わいせつな表現（未成年文脈は0件）",
+     "wordlist": ["adult"], "cooccurrence": ["minor_sexual_context"],
+     "blocklist": ["ut1:adult", "ut1:mixed_adult", "ut1:child", "local:domains", "local:rules"],
+     "classifier": ["Sexual Content or Sexual Acts"]},
+    {"item": 6, "title": "暴力・自傷・自殺の助長、危害を加える具体的手順",
+     "wordlist": ["violence"], "cooccurrence": [], "blocklist": [],
+     "classifier": ["Violent", "Suicide & Self-Harm"]},
+    {"item": 7, "title": "差別・ヘイト、誹謗中傷",
+     "wordlist": ["discrimination"], "cooccurrence": [], "blocklist": ["ut1:agressif"],
+     "classifier": ["Unethical Acts"]},
+    {"item": 8, "title": "違法行為の手引き（薬物、武器、詐欺、不正アクセス等）",
+     "wordlist": ["crime"], "cooccurrence": ["illegal_howto"],
+     "blocklist": ["ut1:drogue", "ut1:dangerous_material", "ut1:hacking"],
+     "classifier": ["Non-violent Illegal Acts"]},
+    {"item": 9, "title": "過激な政治・宗教プロパガンダ、陰謀論",
+     "wordlist": ["propaganda_conspiracy"], "cooccurrence": [], "blocklist": ["ut1:sect", "ut1:fakenews"],
+     "classifier": ["Politically Sensitive Topics"]},
+    {"item": 10, "title": "スパム・詐欺・アダルト・違法コピー配布サイト由来のページ",
+     "wordlist": ["spam"], "cooccurrence": [],
+     "blocklist": ["ut1:adult", "ut1:mixed_adult", "ut1:gambling", "ut1:phishing", "ut1:malware", "ut1:warez",
+                   "ut1:cryptojacking", "ut1:stalkerware", "ut1:ddos", "ut1:dating", "local:domains", "local:rules"],
+     "classifier": ["Copyright Violation"]},
+]
+
+
+def _read_jsonl(path: Path) -> list[dict[str, Any]]:
+    if not path or not path.exists():
+        return []
+    with path.open(encoding="utf-8") as handle:
+        return [json.loads(line) for line in handle if line.strip()]
+
+
+def _snippet(record: dict[str, Any], terms: list[str], length: int = 90) -> str:
+    text = normalize(record.get("content") or "")
+    position = -1
+    for term in terms:
+        position = text.find(term)
+        if position >= 0:
+            break
+    start = max(0, position - length // 3) if position >= 0 else 0
+    return text[start:start + length].replace("\n", " ").replace("|", "／")
+
+
+def _examples_wordlist(removed: list[dict[str, Any]], category: str, limit: int = 3) -> list[str]:
+    rows = []
+    for record in removed:
+        if category not in record.get("_filter_deleted_categories", []):
+            continue
+        terms = record["_filter_distinct_matched_terms_by_category"].get(category, [])
+        rows.append(f"| {record.get('_filter_record_index')} | {record.get('url', '')[:70]} | {', '.join(terms[:5])} | {_snippet(record, terms)} |")
+        if len(rows) >= limit:
+            break
+    return rows
+
+
+def _examples_cooccurrence(review: list[dict[str, Any]], rule: str, limit: int = 3) -> list[str]:
+    rows = []
+    for item in review:
+        if item["rule"] != rule:
+            continue
+        pairs = ", ".join(f"{p['a']}×{p['b']}" for p in item["pairs"][:3])
+        rows.append(f"| {item['record_index']} | {item.get('url', '')[:70]} | {pairs} | {item['excerpt'][:90].replace('|', '／')} |")
+        if len(rows) >= limit:
+            break
+    return rows
+
+
+def _examples_blocklist(removed: list[dict[str, Any]], sources: list[str], limit: int = 3) -> list[str]:
+    rows = []
+    for record in removed:
+        hits = [m for m in record.get("_filter_domain_matches", []) if m["source"] in sources and m["action"] == "delete"]
+        if not hits:
+            continue
+        rows.append(f"| {record.get('_filter_record_index')} | {record.get('url', '')[:70]} | {hits[0]['source']} ({hits[0]['matched'][:40]}) | |")
+        if len(rows) >= limit:
+            break
+    return rows
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--output-root", type=Path, required=True)
+    parser.add_argument("--mode", default="distinct_terms_3plus")
+    parser.add_argument("--classified", type=Path, default=None, help="classify_qwen3guard.py の出力JSONL")
+    parser.add_argument("--review-tally", type=Path, default=None, help="review_tally.py の出力JSON")
+    parser.add_argument("--sampling-manifest", type=Path, default=None)
+    parser.add_argument("--output", type=Path, default=None, help="既定は <output-root>/audit_report.md")
+    args = parser.parse_args(argv)
+
+    mode_dir = args.output_root / args.mode
+    summary = json.loads((mode_dir / "summary.json").read_text(encoding="utf-8"))
+    removed = _read_jsonl(mode_dir / "removed.jsonl")
+    review = _read_jsonl(mode_dir / "cooccurrence_review.jsonl")
+    classified = _read_jsonl(args.classified) if args.classified else []
+    tally = json.loads(args.review_tally.read_text(encoding="utf-8")) if args.review_tally and args.review_tally.exists() else None
+    sampling = json.loads(args.sampling_manifest.read_text(encoding="utf-8")) if args.sampling_manifest and args.sampling_manifest.exists() else None
+
+    total = summary["total_records_scanned"]
+    block = summary.get("domain_blocklist", {})
+    cooc = summary.get("cooccurrence", {})
+    by_reason = summary.get("records_deleted_by_reason", {})
+
+    # 分類器の集計（層別 × 判定）
+    classifier_by_stratum: dict[str, Counter] = defaultdict(Counter)
+    classifier_by_category: Counter = Counter()
+    for record in classified:
+        classifier_by_stratum[record.get("stratum", "?")][record.get("safety") or "unparsed"] += 1
+        for category in record.get("categories", []):
+            classifier_by_category[category] += 1
+
+    lines: list[str] = []
+    lines.append(f"# 有害コンテンツ監査報告（項目B: 5〜10）")
+    lines.append("")
+    lines.append(f"- 生成日時: {datetime.now(timezone.utc).isoformat()}")
+    lines.append(f"- 対象: `{summary['source_file']}`（行 {summary['row_range']['start_row_inclusive']}〜{summary['row_range']['end_row_exclusive']}、{total:,} 文書）")
+    lines.append(f"- 削除合計: {summary['records_deleted']:,} 文書（{summary['deletion_rate']*100:.2f}%）。理由別: ワードリスト {by_reason.get('wordlist', 0):,}、ドメインブロックリスト {by_reason.get('domain_blocklist', 0):,}、近接共起 {by_reason.get('cooccurrence', 0):,}、複数理由 {by_reason.get('multiple_reasons', 0):,}")
+    lines.append("")
+    lines.append("## 適用した手法")
+    lines.append("")
+    lines.append("| 手法 | 状態 | 内容 |")
+    lines.append("|---|---|---|")
+    lines.append(f"| 辞書（ワードリスト） | 適用 | カテゴリ別語彙、同一カテゴリ{summary['threshold']}語以上で削除。除外語: " + ", ".join(f"{k} {len(v)}" for k, v in summary.get("wordlist_excluded_terms_by_category", {}).items()) + " |")
+    lines.append(f"| 辞書（近接共起規則） | {'適用' if cooc.get('enabled') else '未適用'} | " + "; ".join(f"{r['name']}（{r['label_ja']}、{r['window']}文字以内）" for r in cooc.get("rules", [])) + " |")
+    lines.append(f"| ドメインブロックリスト | {'適用' if block.get('enabled') else '未適用'} | " + ", ".join(f"{s['name']}={s['entries']:,}" for s in block.get("sources", [])) + " |")
+    if classified:
+        lines.append(f"| 分類器 | 適用（サンプル） | {classified[0].get('model', '')} を {len(classified)} 文書へ適用。判定: " + ", ".join(f"{k} {v}" for k, v in sorted(Counter(r.get('safety') or 'unparsed' for r in classified).items())) + " |")
+    else:
+        lines.append("| 分類器 | 未適用 | `classify_qwen3guard.py` の出力を `--classified` で渡す |")
+    if tally:
+        reviewed = sum(e.get("reviewed", 0) for e in tally["strata"].values())
+        lines.append(f"| 目視 | {'適用' if reviewed else '未記入'} | 判定済み {reviewed} 件、判定者 {', '.join(tally.get('reviewers', [])) or '未記入'} |")
+    else:
+        lines.append("| 目視 | 未適用 | `sample_for_review.py` → 記入 → `review_tally.py` の結果を `--review-tally` で渡す |")
+    lines.append("")
+    methods_applied = 1 + (1 if classified else 0) + (1 if tally and any(e.get("reviewed") for e in tally["strata"].values()) else 0)
+    lines.append(f"手法数: {methods_applied}/3。" + ("3手法が揃っており「実施」と表示できます。" if methods_applied >= 3 else "3手法が揃うまでは「実施」としないこと。"))
+    lines.append("")
+
+    if block.get("enabled"):
+        lines.append("## 適用したドメインブロックリスト")
+        lines.append("")
+        lines.append("| リスト | 動作 | 件数 | 一致文書 | 削除文書 | 取得元 | 取得日時 | SHA-256 |")
+        lines.append("|---|---|---:|---:|---:|---|---|---|")
+        for source in block["sources"]:
+            stat = block["by_source"].get(source["name"], {})
+            lines.append(f"| {source['name']} | {source['action']} | {source['entries']:,} | {stat.get('records_matched', 0)} | {stat.get('records_deleted', 0)} | {source.get('source_url') or source.get('path')} | {source.get('fetched_at_utc') or ''} | {(source.get('sha256') or '')[:16]} |")
+        lines.append("")
+
+    for spec in AUDIT_ITEMS:
+        lines.append(f"## 項目{spec['item']}: {spec['title']}")
+        lines.append("")
+        counts_lines = []
+        for category in spec["wordlist"]:
+            cat = summary["by_category"].get(category, {})
+            counts_lines.append(f"- ワードリスト `{category}`: 一致 {cat.get('records_with_match', 0):,} 文書、削除 {cat.get('records_deleted', 0):,} 文書（{cat.get('distinct_terms_matched', 0)} 語が一致）")
+        for rule in spec["cooccurrence"]:
+            stat = cooc.get("by_rule", {}).get(rule)
+            if stat is not None:
+                counts_lines.append(f"- 近接共起 `{rule}`（{stat['label_ja']}）: 一致・削除 {stat['records_matched']:,} 文書。全件を `cooccurrence_review.jsonl` で目視確認する")
+        for source_name in spec["blocklist"]:
+            stat = block.get("by_source", {}).get(source_name)
+            if stat is not None:
+                counts_lines.append(f"- ブロックリスト `{source_name}`（{stat['action']}）: 一致 {stat['records_matched']:,} 文書、削除 {stat['records_deleted']:,} 文書")
+        if classified:
+            hit = sum(1 for r in classified if any(c in spec["classifier"] for c in r.get("categories", [])))
+            counts_lines.append(f"- 分類器: サンプル {len(classified)} 件中 {hit} 件が {', '.join(spec['classifier'])} に該当")
+        if tally:
+            for stratum, entry in tally["strata"].items():
+                if any(stratum.endswith(":" + c) for c in spec["wordlist"] + spec["cooccurrence"]):
+                    rate = entry.get("precision", entry.get("harmful_rate"))
+                    counts_lines.append(f"- 目視 `{stratum}`: harmful {entry['harmful']}、not_harmful {entry['not_harmful']}、unsure {entry['unsure']}、未確認 {entry['unreviewed']}" + (f"、精度 {rate}" if rate is not None else ""))
+        lines.extend(counts_lines or ["- 該当する検出手段なし"])
+        if spec["item"] == 5:
+            minor = cooc.get("by_rule", {}).get("minor_sexual_context", {})
+            lines.append(f"- 未成年文脈: 共起規則で {minor.get('records_matched', 0):,} 文書を削除。保持データ側の残存は目視層 `cooccurrence:minor_sexual_context` と `retained:random` の確認結果で判断する")
+        lines.append("")
+        lines.append("例（最大3件）:")
+        lines.append("")
+        lines.append("| record_index | URL | 該当語・規則 | 抜粋 |")
+        lines.append("|---|---|---|---|")
+        examples: list[str] = []
+        for category in spec["wordlist"]:
+            examples.extend(_examples_wordlist(removed, category))
+        for rule in spec["cooccurrence"]:
+            examples.extend(_examples_cooccurrence(review, rule))
+        examples.extend(_examples_blocklist(removed, spec["blocklist"]))
+        lines.extend(examples[:3] if examples else ["| | （該当なし） | | |"])
+        lines.append("")
+
+    if sampling:
+        lines.append("## 目視サンプル")
+        lines.append("")
+        lines.append(f"- 抽出日時 {sampling['created_at_utc']}、seed {sampling['seed']}、合計 {sampling['total_samples']} 件")
+        lines.append("- 層別件数: " + ", ".join(f"{k} {v}" for k, v in sampling["strata"].items()))
+        lines.append("")
+    if classified:
+        lines.append("## 分類器の層別結果")
+        lines.append("")
+        lines.append("| 層 | Safe | Controversial | Unsafe | 未解析 |")
+        lines.append("|---|---:|---:|---:|---:|")
+        for stratum, counter in sorted(classifier_by_stratum.items()):
+            lines.append(f"| {stratum} | {counter.get('Safe', 0)} | {counter.get('Controversial', 0)} | {counter.get('Unsafe', 0)} | {counter.get('unparsed', 0)} |")
+        lines.append("")
+        lines.append("カテゴリ別: " + ", ".join(f"{k} {v}" for k, v in classifier_by_category.most_common()))
+        lines.append("")
+
+    output = args.output or (args.output_root / "audit_report.md")
+    output.write_text("\n".join(lines) + "\n", encoding="utf-8")
+    print(f"wrote {output} ({len(lines)} lines); methods_applied={methods_applied}/3")
+
+
+if __name__ == "__main__":
+    main()

code/e5cb5ca/src/blocklists/blocklist_config.json

@@ -0,0 +1,32 @@
+{
+  "ut1": {
+    "description_ja": "UT1 blacklists（トゥールーズ・キャピトル大学）。delete は該当文書を削除、flag は記録のみ。",
+    "categories": {
+      "adult": "delete",
+      "mixed_adult": "delete",
+      "child": "delete",
+      "gambling": "delete",
+      "phishing": "delete",
+      "malware": "delete",
+      "warez": "delete",
+      "cryptojacking": "delete",
+      "stalkerware": "delete",
+      "ddos": "delete",
+      "dangerous_material": "delete",
+      "drogue": "delete",
+      "sect": "delete",
+      "agressif": "delete",
+      "hacking": "flag",
+      "fakenews": "flag",
+      "dating": "flag"
+    }
+  },
+  "local": {
+    "description_ja": "このリポジトリで管理する日本語Web向けの補助リスト。",
+    "domains": "ja_domains_blocklist.txt",
+    "rules": "ja_domain_token_rules.txt",
+    "action": "delete",
+    "allowlist": "ja_domain_allowlist.txt",
+    "allowlist_note_ja": "allowlist のドメインには UT1 のドメイン一致を適用しない（自前リスト・規則・本文判定は適用する）。"
+  }
+}

code/e5cb5ca/src/blocklists/ja_domain_allowlist.txt

@@ -0,0 +1,17 @@
+# UT1 のドメイン一致を適用しない許可リスト。形式: ドメイン [理由]。サブドメインも対象。
+# 多数のサイトが同居するプラットフォームや、成人向け区画を持つだけの大規模一般サイトは、
+# ドメイン単位の削除だと一般コンテンツを大量に失うため、本文のワードリスト・共起規則で判定する。
+# 根拠: common_crawl_0_filtered_0001 で ut1:adult に一致した上位ドメイン。
+fc2.com 共用ブログホスト（blogNN.fc2.com）。個別ブログは本文で判定
+pixiv.net イラスト投稿プラットフォーム。R-18は一部
+dmm.com 総合EC・ゲーム。成人向けは dmm.co.jp
+dlsite.com 同人ショップ。成人向けは /maniax 配下
+papy.co.jp 電子書籍ストア
+shueisha.co.jp 出版社（週刊プレイボーイ等）
+cosmopolitan.com 一般誌
+hatenablog.com 共用ブログホスト
+livedoor.jp 共用ブログホスト
+ameblo.jp 共用ブログホスト
+seesaa.net 共用ブログホスト
+exblog.jp 共用ブログホスト
+goo.ne.jp ポータル・共用ブログ

code/e5cb5ca/src/blocklists/ja_domain_token_rules.txt

@@ -0,0 +1,6 @@
+# ドメイン名規則。形式: ラベル<TAB>正規表現（ホスト名に対して search）。
+# トークン境界（先頭・ドット・ハイフン）を要求し、hero.jp のような偶然の部分一致を避ける。
+# adult（adhd-adult.info）と deai（出会いアプリ紹介）は誤検出が多いため2026-09-04に除外。
+gambling	(^|[.-])(online)?(casino|casinos|kajino|onkaji|onlinecasino)[a-z0-9-]*([.-]|$)
+adult	(^|[.-])(porn[a-z0-9]*|xxx|hentai[a-z0-9]*|sexy[a-z0-9]*|sex(movie|video|blog|site|douga|gazou)[a-z0-9]*|ero(manga|douga|ge|anime|video|movie|gazou|blog|site|[0-9]+)?|eroero|nukige|fuzoku|18kin|nozoki[a-z0-9]*)([.-]|$)
+warez	(^|[.-])(warez|torrents?|keygen|serials?|crackz?)([.-]|$)

code/e5cb5ca/src/blocklists/ja_domains_blocklist.txt

@@ -0,0 +1,15 @@
+# 自前ドメインブロックリスト。形式: ドメイン [ラベル]。サブドメインも一致する。
+# 根拠: common_crawl_0_filtered_0001 の有害フィルタ削除文書のうち、ドメイン名と内容から
+# サイト全体が対象カテゴリと判断できたもの。追加時はコメントに根拠を残すこと。
+oshiete-onlinecasino.net gambling
+onlinecasinofan.com gambling
+onlinecasinoget.com gambling
+on-casi.info gambling
+on-linecasinoplay.com gambling
+win-spin-casinos-deposit.site gambling
+casinotop10.jp gambling
+japanesecasinoreview.com gambling
+ero-mangalife.com adult
+sexyaction.net adult
+sexynews24.info adult
+nozokima.site adult

code/e5cb5ca/src/classify_qwen3guard.py

@@ -0,0 +1,161 @@
+"""Qwen3Guard-Gen による有害性分類（監査の第2手法）。
+
+辞書・ブロックリスト・共起規則とは独立した分類器として、目視サンプルや
+境界文書に適用する。全件へ適用するには計算量が大きいため、
+``sample_for_review.py`` が出力するサンプルJSONLを入力にする想定。
+
+入力JSONL: ``{"id": ..., "url": ..., "text": ..., "match_positions": [..]}``
+出力JSONL: 入力に ``safety``（Safe/Unsafe/Controversial）、``categories``、
+``raw_output``、``elapsed_s`` を加えたもの。併せて ``<output>.manifest.json`` に
+モデル名・リビジョン・実行条件を記録する。
+
+依存関係は ``uv sync --group classifier`` で導入する（torch, transformers）。
+
+    uv run python abeja-cc-ja/src/classify_qwen3guard.py --input samples.jsonl --output classified.jsonl
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+
+DEFAULT_MODEL = "Qwen/Qwen3Guard-Gen-0.6B"
+SAFETY_RE = re.compile(r"Safety:\s*(Safe|Unsafe|Controversial)")
+CATEGORY_RE = re.compile(
+    r"(Violent|Non-violent Illegal Acts|Sexual Content or Sexual Acts|PII|Suicide & Self-Harm|"
+    r"Unethical Acts|Politically Sensitive Topics|Copyright Violation|Jailbreak|None)"
+)
+# Qwen3Guard のカテゴリと監査項目（5〜10）の対応。
+CATEGORY_TO_AUDIT_ITEM = {
+    "Sexual Content or Sexual Acts": 5,
+    "Violent": 6,
+    "Suicide & Self-Harm": 6,
+    "Unethical Acts": 7,
+    "Non-violent Illegal Acts": 8,
+    "Politically Sensitive Topics": 9,
+    "Copyright Violation": 10,
+}
+
+
+def build_excerpt(text: str, positions: list[int] | None, max_chars: int, window: int = 300, head: int = 1000) -> str:
+    """先頭と、一致位置の前後を優先して抜粋する。長文をそのまま渡さない。"""
+
+    if len(text) <= max_chars:
+        return text
+    pieces: list[tuple[int, int]] = [(0, min(head, len(text)))]
+    for position in (positions or [])[:4]:
+        pieces.append((max(0, position - window), min(len(text), position + window)))
+    pieces.sort()
+    merged: list[list[int]] = []
+    for start, end in pieces:
+        if merged and start <= merged[-1][1]:
+            merged[-1][1] = max(merged[-1][1], end)
+        else:
+            merged.append([start, end])
+    excerpt = " … ".join(text[start:end] for start, end in merged)
+    return excerpt[:max_chars]
+
+
+def parse_output(content: str) -> tuple[str | None, list[str]]:
+    safety = SAFETY_RE.search(content)
+    categories = [item for item in CATEGORY_RE.findall(content) if item != "None"]
+    return (safety.group(1) if safety else None), sorted(set(categories))
+
+
+def load_model(model_name: str, device: str):
+    import torch
+    from transformers import AutoModelForCausalLM, AutoTokenizer
+
+    tokenizer = AutoTokenizer.from_pretrained(model_name)
+    kwargs: dict[str, Any] = {}
+    if device == "auto":
+        kwargs["device_map"] = "auto"
+    try:
+        model = AutoModelForCausalLM.from_pretrained(model_name, dtype="auto", **kwargs)
+    except TypeError:
+        model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype="auto", **kwargs)
+    if device != "auto":
+        model = model.to(device)
+    model.eval()
+    return tokenizer, model, torch
+
+
+def classify_text(tokenizer, model, torch, text: str, max_new_tokens: int = 64) -> str:
+    messages = [{"role": "user", "content": text}]
+    prompt = tokenizer.apply_chat_template(messages, tokenize=False)
+    inputs = tokenizer([prompt], return_tensors="pt").to(model.device)
+    with torch.no_grad():
+        generated = model.generate(**inputs, max_new_tokens=max_new_tokens, do_sample=False)
+    output_ids = generated[0][len(inputs.input_ids[0]):].tolist()
+    return tokenizer.decode(output_ids, skip_special_tokens=True)
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--input", type=Path, required=True)
+    parser.add_argument("--output", type=Path, required=True)
+    parser.add_argument("--model", default=DEFAULT_MODEL)
+    parser.add_argument("--device", default="auto", help="auto / cpu / mps / cuda")
+    parser.add_argument("--max-chars", type=int, default=3000)
+    parser.add_argument("--max-new-tokens", type=int, default=64)
+    parser.add_argument("--limit", type=int, default=None)
+    args = parser.parse_args(argv)
+
+    tokenizer, model, torch = load_model(args.model, args.device)
+    revision = getattr(getattr(model, "config", None), "_commit_hash", None)
+    started = datetime.now(timezone.utc).isoformat()
+    counts: dict[str, int] = {"Safe": 0, "Unsafe": 0, "Controversial": 0, "unparsed": 0}
+    processed = 0
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    with args.input.open(encoding="utf-8") as reader, args.output.open("w", encoding="utf-8") as writer:
+        for line in reader:
+            if not line.strip():
+                continue
+            if args.limit is not None and processed >= args.limit:
+                break
+            record = json.loads(line)
+            text = build_excerpt(record.get("text") or "", record.get("match_positions"), args.max_chars)
+            t0 = time.perf_counter()
+            raw = classify_text(tokenizer, model, torch, text, args.max_new_tokens)
+            elapsed = time.perf_counter() - t0
+            safety, categories = parse_output(raw)
+            counts[safety or "unparsed"] += 1
+            record.update({
+                "safety": safety,
+                "categories": categories,
+                "audit_items": sorted({CATEGORY_TO_AUDIT_ITEM[c] for c in categories if c in CATEGORY_TO_AUDIT_ITEM}),
+                "raw_output": raw.strip(),
+                "excerpt_chars": len(text),
+                "elapsed_s": round(elapsed, 3),
+                "model": args.model,
+            })
+            record.pop("text", None)
+            writer.write(json.dumps(record, ensure_ascii=False, separators=(",", ":")) + "\n")
+            processed += 1
+    manifest = {
+        "model": args.model,
+        "model_revision": revision,
+        "device": str(model.device),
+        "max_chars": args.max_chars,
+        "max_new_tokens": args.max_new_tokens,
+        "started_at_utc": started,
+        "finished_at_utc": datetime.now(timezone.utc).isoformat(),
+        "input": str(args.input),
+        "output": str(args.output),
+        "processed": processed,
+        "counts": counts,
+        "category_to_audit_item": CATEGORY_TO_AUDIT_ITEM,
+        "taxonomy_note": "Qwen3Guard: Safe / Controversial / Unsafe。Controversial は文脈依存の判定。",
+    }
+    Path(str(args.output) + ".manifest.json").write_text(json.dumps(manifest, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+    print(json.dumps({"processed": processed, "counts": counts, "model": args.model}, ensure_ascii=False))
+
+
+if __name__ == "__main__":
+    main()

code/e5cb5ca/src/cooccurrence.py

@@ -0,0 +1,136 @@
+"""2種類の語群が近接して現れる文書を検出する近接共起規則。
+
+単語リストの密度（同一カテゴリ3語以上）では判別できない次の2種類を扱う。
+
+* 未成年を示す語 × 性的な語（監査項目5「未成年が登場する文脈は0件」）
+* 違法行為の対象語 × 手引きを示す語（監査項目8「違法行為の手引き」）
+
+規則は ``wordlists/cooccurrence/rules.json`` に定義し、語リストは同じ
+ディレクトリの1行1語ファイルから読む。一致した文書は削除対象になると同時に、
+全件が目視確認用の ``cooccurrence_review.jsonl`` へ書き出される。
+"""
+
+from __future__ import annotations
+
+import bisect
+import json
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from textmatch import compile_trie_pattern, normalize, read_terms
+
+
+@dataclass(frozen=True)
+class CooccurrenceRule:
+    name: str
+    category: str
+    label_ja: str
+    terms_a: tuple[str, ...]
+    terms_b: tuple[str, ...]
+    window: int
+    description_ja: str = ""
+    terms_a_file: str = ""
+    terms_b_file: str = ""
+
+
+def load_rules(path: Path) -> list[CooccurrenceRule]:
+    """規則定義JSONと語リストを読む。語リストのパスはJSONからの相対パス。"""
+
+    spec = json.loads(path.read_text(encoding="utf-8"))
+    base = path.parent
+    rules: list[CooccurrenceRule] = []
+    for item in spec["rules"]:
+        terms_a = read_terms(base / item["terms_a"])
+        terms_b = read_terms(base / item["terms_b"])
+        if not terms_a or not terms_b:
+            raise ValueError(f"規則 {item['name']} の語リストが空です: {item['terms_a']}, {item['terms_b']}")
+        rules.append(
+            CooccurrenceRule(
+                name=item["name"],
+                category=item["category"],
+                label_ja=item["label_ja"],
+                terms_a=tuple(dict.fromkeys(terms_a)),
+                terms_b=tuple(dict.fromkeys(terms_b)),
+                window=int(item.get("window", 100)),
+                description_ja=item.get("description_ja", ""),
+                terms_a_file=item["terms_a"],
+                terms_b_file=item["terms_b"],
+            )
+        )
+    return rules
+
+
+class CooccurrenceDetector:
+    """各規則について、語群Aと語群Bの出現位置が window 文字以内の組を探す。"""
+
+    def __init__(self, rules: list[CooccurrenceRule]) -> None:
+        self.rules = rules
+        self._patterns = [
+            (
+                rule,
+                compile_trie_pattern(sorted(rule.terms_a, key=lambda t: (-len(t), t))),
+                compile_trie_pattern(sorted(rule.terms_b, key=lambda t: (-len(t), t))),
+            )
+            for rule in rules
+        ]
+
+    def describe(self) -> list[dict[str, Any]]:
+        return [
+            {
+                "name": rule.name,
+                "category": rule.category,
+                "label_ja": rule.label_ja,
+                "window": rule.window,
+                "terms_a_file": rule.terms_a_file,
+                "terms_a_count": len(rule.terms_a),
+                "terms_b_file": rule.terms_b_file,
+                "terms_b_count": len(rule.terms_b),
+                "description_ja": rule.description_ja,
+            }
+            for rule in self.rules
+        ]
+
+    def detect(self, text: Any, max_pairs: int = 10, excerpt_margin: int = 60) -> list[dict[str, Any]]:
+        normalized = normalize(text)
+        if not normalized:
+            return []
+        results: list[dict[str, Any]] = []
+        for rule, pattern_a, pattern_b in self._patterns:
+            a_hits = [(found.start(), found.group(0)) for found in pattern_a.finditer(normalized)]
+            if not a_hits:
+                continue
+            b_hits = [(found.start(), found.group(0)) for found in pattern_b.finditer(normalized)]
+            if not b_hits:
+                continue
+            b_positions = [position for position, _ in b_hits]
+            pairs: list[dict[str, Any]] = []
+            for a_position, a_term in a_hits:
+                low = bisect.bisect_left(b_positions, a_position - rule.window)
+                high = bisect.bisect_right(b_positions, a_position + rule.window)
+                for b_position, b_term in b_hits[low:high]:
+                    pairs.append(
+                        {
+                            "a": a_term,
+                            "b": b_term,
+                            "distance": abs(a_position - b_position),
+                            "position": min(a_position, b_position),
+                        }
+                    )
+            if not pairs:
+                continue
+            pairs.sort(key=lambda pair: (pair["position"], pair["distance"]))
+            first = pairs[0]
+            start = max(0, first["position"] - excerpt_margin)
+            end = min(len(normalized), first["position"] + rule.window + excerpt_margin)
+            results.append(
+                {
+                    "rule": rule.name,
+                    "category": rule.category,
+                    "label_ja": rule.label_ja,
+                    "pair_count": len(pairs),
+                    "pairs": pairs[:max_pairs],
+                    "excerpt": normalized[start:end].replace("\n", " "),
+                }
+            )
+        return results

code/e5cb5ca/src/domain_blocklist.py

@@ -0,0 +1,351 @@
+"""URLのドメインをブロックリストと照合する。
+
+UT1 blacklists（トゥールーズ・キャピトル大学、CC BY-SA）のカテゴリ別リストと、
+このリポジトリで管理するドメインリスト・ドメイン名規則を統合する。適用した
+リストの出典・取得日時・SHA-256・件数はマニフェストとして summary.json に
+記録する（監査項目10「適用したリストを記録」）。
+
+取得::
+
+    python domain_blocklist.py fetch --dest ../data/blocklists/ut1
+
+確認::
+
+    python domain_blocklist.py check https://example.com/path ...
+
+設定は ``blocklists/blocklist_config.json`` にあり、UT1カテゴリごとに
+``delete``（削除）か ``flag``（記録のみ）を指定する。
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import io
+import json
+import re
+import tarfile
+import unicodedata
+import urllib.error
+import urllib.request
+from dataclasses import asdict, dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Iterable
+from urllib.parse import urlparse
+
+
+UT1_DOWNLOAD_URL = "https://dsi.ut-capitole.fr/blacklists/download/{category}.tar.gz"
+UT1_MIRROR_URL = "https://raw.githubusercontent.com/olbat/ut1-blacklists/master/blacklists/{category}/{member}"
+UT1_LICENSE = "CC BY-SA 4.0 (Université Toulouse Capitole, Fabrice Prigent)"
+CONFIG_FILE = "blocklist_config.json"
+MANIFEST_FILE = "manifest.json"
+USER_AGENT = "MHI_Dataset-domain-blocklist/1.0"
+
+
+@dataclass(frozen=True)
+class BlocklistSource:
+    """適用したリスト1件分のメタデータ。summary.json にそのまま記録する。"""
+
+    name: str
+    kind: str  # ut1 | local_domains | local_rules
+    action: str  # delete | flag
+    entries: int
+    path: str
+    license: str = ""
+    source_url: str | None = None
+    sha256: str | None = None
+    fetched_at_utc: str | None = None
+
+
+def normalize_host(url: Any) -> str | None:
+    """URLからホスト名を取り出す。小文字化し、ポートと末尾のドットを除く。"""
+
+    if not url:
+        return None
+    text = unicodedata.normalize("NFKC", str(url)).strip().lower()
+    if "://" not in text:
+        text = "http://" + text
+    try:
+        host = urlparse(text).hostname
+    except ValueError:
+        return None
+    if not host:
+        return None
+    return host.strip(".")
+
+
+def host_suffixes(host: str) -> list[str]:
+    """``a.b.example.com`` → ``[a.b.example.com, b.example.com, example.com]``（TLD単独は除く）。"""
+
+    parts = host.split(".")
+    return [".".join(parts[index:]) for index in range(len(parts) - 1)]
+
+
+def _sha256(data: bytes) -> str:
+    return hashlib.sha256(data).hexdigest()
+
+
+def _download(url: str, timeout: int) -> bytes:
+    request = urllib.request.Request(url, headers={"User-Agent": USER_AGENT})
+    with urllib.request.urlopen(request, timeout=timeout) as response:
+        return response.read()
+
+
+def _count_entries(content: bytes) -> int:
+    return sum(1 for line in content.splitlines() if line.strip() and not line.startswith(b"#"))
+
+
+def fetch_ut1(categories: Iterable[str], dest: Path, timeout: int = 300, prefer_mirror: bool = False) -> dict[str, Any]:
+    """UT1のカテゴリ別tarballを取得し、domains/urls を展開してマニフェストを書く。
+
+    公式サイトが応答しない場合はGitHubミラー（olbat/ut1-blacklists）へ
+    フォールバックする。どちらから取得したかはマニフェストに残る。
+    """
+
+    dest.mkdir(parents=True, exist_ok=True)
+    manifest: dict[str, Any] = {
+        "source": "UT1 blacklists",
+        "license": UT1_LICENSE,
+        "fetched_at_utc": datetime.now(timezone.utc).isoformat(),
+        "categories": {},
+    }
+    for category in categories:
+        entry: dict[str, Any] = {}
+        members: dict[str, bytes] = {}
+        data: bytes | None = None
+        if not prefer_mirror:
+            official_url = UT1_DOWNLOAD_URL.format(category=category)
+            try:
+                data = _download(official_url, timeout)
+                entry["source_url"] = official_url
+            except (urllib.error.URLError, TimeoutError, OSError) as error:
+                entry["official_error"] = str(error)
+        if data is not None:
+            entry["sha256"] = _sha256(data)
+            entry["bytes"] = len(data)
+            with tarfile.open(fileobj=io.BytesIO(data), mode="r:gz") as archive:
+                for member in archive.getmembers():
+                    name = Path(member.name).name
+                    if name in ("domains", "urls") and member.isfile():
+                        handle = archive.extractfile(member)
+                        if handle is not None:
+                            members[name] = handle.read()
+        else:
+            for name in ("domains", "urls"):
+                mirror_url = UT1_MIRROR_URL.format(category=category, member=name)
+                try:
+                    members[name] = _download(mirror_url, timeout)
+                except urllib.error.HTTPError as error:
+                    if error.code != 404:
+                        raise
+            entry["source_url"] = UT1_MIRROR_URL.format(category=category, member="{domains,urls}")
+            entry["sha256"] = _sha256(b"".join(members[name] for name in sorted(members)))
+            entry["bytes"] = sum(len(value) for value in members.values())
+        if "domains" not in members:
+            raise RuntimeError(f"UT1カテゴリ {category} の domains を取得できませんでした")
+        category_dir = dest / category
+        category_dir.mkdir(parents=True, exist_ok=True)
+        for name, content in members.items():
+            (category_dir / name).write_bytes(content)
+            entry[f"{name}_entries"] = _count_entries(content)
+        manifest["categories"][category] = entry
+    (dest / MANIFEST_FILE).write_text(json.dumps(manifest, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+    return manifest
+
+
+def _read_list_lines(path: Path) -> list[str]:
+    lines: list[str] = []
+    for raw_line in path.read_text(encoding="utf-8", errors="replace").splitlines():
+        line = raw_line.strip()
+        if line and not line.startswith("#"):
+            lines.append(line)
+    return lines
+
+
+class DomainBlocklist:
+    """ドメイン一致（親ドメインを含む）、URL接頭辞一致、ドメイン名規則の照合。"""
+
+    def __init__(self) -> None:
+        self.sources: list[BlocklistSource] = []
+        self._domain_index: dict[str, list[str]] = {}
+        self._url_index: dict[str, list[tuple[str, str]]] = {}
+        self._rules: list[tuple[str, re.Pattern[str], str]] = []
+        self._actions: dict[str, str] = {}
+        self._allowlist: set[str] = set()
+        self._allowlist_source: str | None = None
+
+    def add_domains(self, source: BlocklistSource, domains: Iterable[str]) -> None:
+        self.sources.append(source)
+        self._actions[source.name] = source.action
+        for domain in domains:
+            self._domain_index.setdefault(domain.lower(), []).append(source.name)
+
+    def add_urls(self, source_name: str, urls: Iterable[str]) -> None:
+        for raw in urls:
+            entry = raw.lower().strip("/")
+            host = entry.split("/", 1)[0]
+            self._url_index.setdefault(host, []).append((entry, source_name))
+
+    def add_rules(self, source: BlocklistSource, rules: Iterable[tuple[str, str]]) -> None:
+        self.sources.append(source)
+        self._actions[source.name] = source.action
+        for label, expression in rules:
+            self._rules.append((label, re.compile(expression), source.name))
+
+    def add_allowlist(self, source: BlocklistSource, domains: Iterable[str]) -> None:
+        """UT1由来のドメイン一致を適用しないドメイン（プラットフォーム等）。"""
+
+        self.sources.append(source)
+        self._actions[source.name] = source.action
+        self._allowlist_source = source.name
+        self._allowlist.update(domain.lower() for domain in domains)
+
+    @classmethod
+    def load(cls, blocklist_dir: Path, cache_dir: Path | None) -> "DomainBlocklist":
+        config = json.loads((blocklist_dir / CONFIG_FILE).read_text(encoding="utf-8"))
+        blocklist = cls()
+        categories: dict[str, str] = config.get("ut1", {}).get("categories", {})
+        if categories:
+            if cache_dir is None or not (cache_dir / MANIFEST_FILE).exists():
+                raise FileNotFoundError(
+                    f"UT1ブロックリストが未取得です: {cache_dir}. 先に "
+                    f"`python {Path(__file__).name} fetch --dest {cache_dir}` を実行してください。"
+                )
+            manifest = json.loads((cache_dir / MANIFEST_FILE).read_text(encoding="utf-8"))
+            for category, action in categories.items():
+                meta = manifest["categories"].get(category)
+                domains_path = cache_dir / category / "domains"
+                if meta is None or not domains_path.exists():
+                    raise FileNotFoundError(f"UT1カテゴリ {category} が取得されていません: {domains_path}")
+                domains = _read_list_lines(domains_path)
+                source = BlocklistSource(
+                    name=f"ut1:{category}",
+                    kind="ut1",
+                    action=action,
+                    entries=len(domains),
+                    path=str(domains_path),
+                    license=manifest.get("license", UT1_LICENSE),
+                    source_url=meta.get("source_url"),
+                    sha256=meta.get("sha256"),
+                    fetched_at_utc=manifest.get("fetched_at_utc"),
+                )
+                blocklist.add_domains(source, domains)
+                urls_path = cache_dir / category / "urls"
+                if urls_path.exists():
+                    blocklist.add_urls(source.name, _read_list_lines(urls_path))
+        local = config.get("local", {})
+        if local.get("allowlist"):
+            path = blocklist_dir / local["allowlist"]
+            domains = [line.split()[0].lower() for line in _read_list_lines(path)]
+            blocklist.add_allowlist(
+                BlocklistSource(
+                    name="local:allowlist",
+                    kind="local_allowlist",
+                    action="allow",
+                    entries=len(domains),
+                    path=str(path),
+                    license="repository",
+                    sha256=_sha256(path.read_bytes()),
+                ),
+                domains,
+            )
+        if local.get("domains"):
+            path = blocklist_dir / local["domains"]
+            domains = [line.split()[0].lower() for line in _read_list_lines(path)]
+            source = BlocklistSource(
+                name="local:domains",
+                kind="local_domains",
+                action=local.get("action", "delete"),
+                entries=len(domains),
+                path=str(path),
+                license="repository",
+                sha256=_sha256(path.read_bytes()),
+            )
+            blocklist.add_domains(source, domains)
+        if local.get("rules"):
+            path = blocklist_dir / local["rules"]
+            rules: list[tuple[str, str]] = []
+            for line in _read_list_lines(path):
+                label, _, expression = line.partition("\t")
+                if not expression:
+                    raise ValueError(f"規則の形式が不正です（ラベル<TAB>正規表現）: {line}")
+                rules.append((label.strip(), expression.strip()))
+            source = BlocklistSource(
+                name="local:rules",
+                kind="local_rules",
+                action=local.get("action", "delete"),
+                entries=len(rules),
+                path=str(path),
+                license="repository",
+                sha256=_sha256(path.read_bytes()),
+            )
+            blocklist.add_rules(source, rules)
+        return blocklist
+
+    def match(self, url: Any) -> list[dict[str, Any]]:
+        host = normalize_host(url)
+        if not host:
+            return []
+        results: list[dict[str, Any]] = []
+        seen: set[tuple[str, str]] = set()
+
+        def add(source_name: str, matched: str, kind: str) -> None:
+            key = (source_name, matched)
+            if key not in seen:
+                seen.add(key)
+                results.append({"source": source_name, "action": self._actions[source_name], "matched": matched, "kind": kind})
+
+        suffixes = host_suffixes(host)
+        allowed = next((suffix for suffix in suffixes if suffix in self._allowlist), None)
+        for suffix in suffixes:
+            for source_name in self._domain_index.get(suffix, ()):
+                if allowed is not None and source_name.startswith("ut1:"):
+                    add(self._allowlist_source or "local:allowlist", f"{allowed} (suppressed {source_name})", "allowlist")
+                    continue
+                add(source_name, suffix, "domain")
+        if self._url_index and allowed is None:
+            path = urlparse(unicodedata.normalize("NFKC", str(url)).strip().lower()).path or "/"
+            full = host + path.rstrip("/")
+            for suffix in suffixes:
+                for entry, source_name in self._url_index.get(suffix, ()):
+                    if full == entry or full.startswith(entry + "/"):
+                        add(source_name, entry, "url")
+        for label, pattern, source_name in self._rules:
+            if pattern.search(host):
+                add(source_name, f"{label}:{pattern.pattern}", "rule")
+        return results
+
+    def manifest(self) -> list[dict[str, Any]]:
+        return [asdict(source) for source in self.sources]
+
+
+def main(argv: list[str] | None = None) -> None:
+    here = Path(__file__).resolve().parent
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    sub = parser.add_subparsers(dest="command", required=True)
+    fetch = sub.add_parser("fetch", help="UT1のカテゴリ別リストを取得する")
+    fetch.add_argument("--dest", type=Path, required=True)
+    fetch.add_argument("--config", type=Path, default=here / "blocklists" / CONFIG_FILE)
+    fetch.add_argument("--category", action="append", default=None, help="省略時は設定ファイルの全カテゴリ")
+    fetch.add_argument("--mirror", action="store_true", help="公式サイトではなくGitHubミラーから取得する")
+    fetch.add_argument("--timeout", type=int, default=300)
+    check = sub.add_parser("check", help="URLを照合して結果を表示する")
+    check.add_argument("urls", nargs="+")
+    check.add_argument("--blocklist-dir", type=Path, default=here / "blocklists")
+    check.add_argument("--cache-dir", type=Path, default=here.parents[0] / "data" / "blocklists" / "ut1")
+    args = parser.parse_args(argv)
+    if args.command == "fetch":
+        config = json.loads(args.config.read_text(encoding="utf-8"))
+        categories = args.category or list(config.get("ut1", {}).get("categories", {}))
+        manifest = fetch_ut1(categories, args.dest, timeout=args.timeout, prefer_mirror=args.mirror)
+        summary = {category: {key: value for key, value in meta.items() if key != "sha256"} for category, meta in manifest["categories"].items()}
+        print(json.dumps(summary, ensure_ascii=False, indent=2))
+    else:
+        blocklist = DomainBlocklist.load(args.blocklist_dir, args.cache_dir)
+        for url in args.urls:
+            print(url, json.dumps(blocklist.match(url), ensure_ascii=False))
+
+
+if __name__ == "__main__":
+    main()

code/e5cb5ca/src/filter_pii.py

@@ -0,0 +1,180 @@
+"""Parquet中の指定PIIをプレースホルダーへ置換する。
+
+実行入口と引数処理は ``main_pii.py`` に置き、このモジュールには置換処理と
+監査集計の定義だけを置く。
+"""
+
+from __future__ import annotations
+
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+import pyarrow as pa
+import pyarrow.parquet as pq
+
+from pii_detector import PII_LABELS_JA, PLACEHOLDERS, PIIDetector, matches_to_dict
+
+
+MODE_NAME = "pii_replace"
+OUTPUT_DIR_NAME = "pii_replaced"
+
+
+def policy_record(approver: str | None, approved_on: str | None, note: str | None = None) -> dict[str, Any]:
+    """処理方針の記録（監査項目12）。方針は全データセット共通で「置換」。
+
+    削除も保持もしないため保持対象の承認は不要だが、方針そのものの承認者と
+    日付を残す。未記入なら ``status`` は ``unapproved`` になる。
+    """
+
+    approved = bool(approver and approved_on)
+    return {
+        "action": "mask_with_placeholders",
+        "name_scope_ja": "個人名＋所属（同じ文の前後25文字に組織名か役職語）、署名（執筆者・著者等の役割ラベル）、ラベル付き氏名を置換。敬称のみ・文脈なしの姓名は既定で保持し件数を記録。",
+        "action_ja": "検出したPIIを種別ごとのプレースホルダーへ置換する。文書の削除も、PIIのままの保持もしない。",
+        "scope_ja": "全データセット共通（url列と content列）",
+        "placeholders": dict(PLACEHOLDERS),
+        "retained_types": [],
+        "approved_by": approver,
+        "approved_on": approved_on,
+        "note": note,
+        "status": "approved" if approved else "unapproved",
+    }
+
+
+def json_safe(value: Any) -> Any:
+    if value is None or isinstance(value, (str, int, bool)):
+        return value
+    if isinstance(value, float):
+        return value if value == value and abs(value) != float("inf") else None
+    if isinstance(value, (list, tuple)):
+        return [json_safe(item) for item in value]
+    if isinstance(value, dict):
+        return {str(key): json_safe(item) for key, item in value.items()}
+    return str(value)
+
+
+def run_filter(
+    input_path: Path,
+    output_root: Path,
+    batch_size: int = 2048,
+    start_row: int = 0,
+    max_rows: int | None = None,
+    policy_approver: str | None = None,
+    policy_approved_on: str | None = None,
+    policy_note: str | None = None,
+    mask_honorific_names: bool = False,
+    mask_bare_names: bool = False,
+    affiliation_titles: bool = True,
+) -> dict[str, Any]:
+    """入力を全件保持し、URL・本文の検出値だけを置換して出力する。"""
+
+    output_dir = output_root / OUTPUT_DIR_NAME
+    output_dir.mkdir(parents=True, exist_ok=True)
+    parquet = pq.ParquetFile(input_path)
+    schema = parquet.schema_arrow
+    replaced_path = output_dir / "replaced.parquet"
+    audit_path = output_dir / "audit.jsonl"
+    writer = pq.ParquetWriter(replaced_path, schema, compression="zstd")
+    audit_handle = audit_path.open("w", encoding="utf-8", newline="\n")
+    detector = PIIDetector(include_url=True, mask_honorific_names=mask_honorific_names, mask_bare_names=mask_bare_names, affiliation_titles=affiliation_titles)
+    scanned_at = datetime.now(timezone.utc).isoformat()
+    by_type = {
+        pii_type: {"label_ja": label, "records_with_match": 0, "replacement_count": 0}
+        for pii_type, label in PII_LABELS_JA.items()
+    }
+    stats: dict[str, Any] = {
+        "filter_mode": MODE_NAME,
+        "criterion_ja": "電話番号、メールアドレス、番地レベル住所、個人名（単体・所属付き）、マイナンバー、カード番号、口座番号をプレースホルダーへ置換し、文書は削除しない",
+        "source_file": str(input_path),
+        "total_records_scanned": 0,
+        "records_with_replacement": 0,
+        "records_changed": 0,
+        "records_unchanged": 0,
+        "total_replacements": 0,
+        "by_type": by_type,
+        "pii_policy": policy_record(policy_approver, policy_approved_on, policy_note),
+        "detector_version": "pii_detector_v3_sudachi",
+        "row_range": {},
+        "input_schema": list(schema.names),
+        "matching_scope": "url + content",
+        "matching_normalization": "NFKC",
+        "method_ja": "正規表現、文脈ラベル、SudachiPy による人名（姓・名）検出と所属・役職・敬称文脈、マイナンバーチェックデジット、クレジットカードLuhn検証を併用。",
+        "note_ja": "外部NERモデルを使用しない決定的ベースライン。監査JSONLにはPII値を保存せず、マスキング済み一致値と置換後フィールドを記録する。残存件数は pii_residual_check.py（GLiNER-ja）で独立に確認する。",
+    }
+    stop_row = start_row + max_rows if max_rows is not None else None
+    row_offset = 0
+    try:
+        for source_batch in parquet.iter_batches(batch_size=batch_size):
+            source_batch_start = row_offset
+            row_offset += source_batch.num_rows
+            if row_offset <= start_row:
+                continue
+            if stop_row is not None and source_batch_start >= stop_row:
+                break
+            local_start = max(0, start_row - source_batch_start)
+            local_end = source_batch.num_rows if stop_row is None else min(source_batch.num_rows, stop_row - source_batch_start)
+            batch = source_batch.slice(local_start, local_end - local_start)
+            rows = batch.to_pylist()
+            replaced_rows: list[dict[str, Any]] = []
+            for row in rows:
+                url = row.get("url") or ""
+                content = row.get("content") or ""
+                replaced_url, replaced_content, matches = detector.replace_record(url, content)
+                output_row = dict(row)
+                if "url" in output_row and row.get("url") is not None:
+                    output_row["url"] = replaced_url
+                if "content" in output_row and row.get("content") is not None:
+                    output_row["content"] = replaced_content
+                replaced_rows.append(output_row)
+                stats["total_records_scanned"] += 1
+                stats["total_replacements"] += len(matches)
+                matched_types: set[str] = set()
+                for match in matches:
+                    by_type[match.pii_type]["replacement_count"] += 1
+                    matched_types.add(match.pii_type)
+                for pii_type in matched_types:
+                    by_type[pii_type]["records_with_match"] += 1
+                if matches:
+                    stats["records_with_replacement"] += 1
+                    stats["records_changed"] += 1
+                    audit_record = {
+                        "record_index": start_row + stats["total_records_scanned"] - 1,
+                        "url_replaced": json_safe(replaced_url),
+                        "content_replaced": json_safe(replaced_content),
+                        "_pii_replaced": True,
+                        "_pii_filter_mode": MODE_NAME,
+                        "_pii_detected_types": sorted(matched_types),
+                        "_pii_detected_types_ja": [PII_LABELS_JA[item] for item in sorted(matched_types)],
+                        "_pii_matches": matches_to_dict(matches),
+                        "_pii_match_count": len(matches),
+                        "_pii_source_file": str(input_path),
+                        "_pii_scanned_at_utc": scanned_at,
+                    }
+                    audit_handle.write(json.dumps(audit_record, ensure_ascii=False, separators=(",", ":")) + "\n")
+                else:
+                    stats["records_unchanged"] += 1
+            writer.write_table(pa.Table.from_pylist(replaced_rows, schema=schema))
+    finally:
+        writer.close()
+        audit_handle.close()
+
+    stats["row_range"] = {
+        "start_row_inclusive": start_row,
+        "end_row_exclusive": start_row + stats["total_records_scanned"],
+    }
+    stats.update({
+        "scanned_at_utc": scanned_at,
+        "person_name_unmasked_candidates": {
+            "honorific_only": {"records": detector.honorific_name_records, "spans": detector.honorific_name_candidates,
+                                "masked": mask_honorific_names, "note_ja": "「○○さん／氏／様」だけの姓名。既定では置換しない（--mask-honorific-names で置換）。"},
+            "bare": {"records": detector.bare_name_records, "spans": detector.bare_name_candidates,
+                     "masked": mask_bare_names, "note_ja": "文脈の無い姓名。既定では置換しない（--mask-bare-names で置換）。"},
+        },
+        "audit_jsonl": str(audit_path),
+        "replaced_parquet": str(replaced_path),
+    })
+    (output_root / "summary.json").write_text(json.dumps(stats, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+    return stats
+

code/e5cb5ca/src/filter_toxic.py

@@ -0,0 +1,587 @@
+"""有害コンテンツのワードリスト検出と文書フィルタリング。
+
+実行入口と引数処理は ``main_toxic.py`` に置き、このモジュールには
+ワードリストの読み込み、照合、出力および集計の定義だけを置く。現在の
+有害コンテンツ条件は、同一カテゴリの異なる語が3種類以上なら削除する
+単一条件（``distinct_terms_3plus``）に限定する。
+
+照合は部分一致だが、語の端がASCII英数字またはカタカナの場合は同種の文字が
+隣接する位置では一致させない（「メイク」中の「イク」、「DVD」中の「dv」を
+防ぐ）。さらに ``wordlists/exclude`` の除外リストで、汎用語を既存リストを
+書き換えずに照合対象から外せる。
+
+削除条件はワードリストのほかに、URLのドメインブロックリスト
+（``domain_blocklist.py``）と近接共起規則（``cooccurrence.py``）がある。
+3系統の判定結果と理由別件数を summary.json と removed.jsonl に記録する。
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from collections import Counter, defaultdict
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Iterable
+
+import pyarrow as pa
+import pyarrow.parquet as pq
+
+from cooccurrence import CooccurrenceDetector
+from domain_blocklist import DomainBlocklist
+from textmatch import ASCII_EDGE, KATAKANA_EDGE, compile_trie_pattern, normalize, read_terms as _read_terms  # noqa: F401
+
+
+CATEGORIES = (
+    "adult",
+    "violence",
+    "discrimination",
+    "crime",
+    "propaganda_conspiracy",
+    "spam",
+)
+
+CATEGORY_LABELS_JA = {
+    "adult": "性的・わいせつ",
+    "violence": "暴力・自傷・自殺",
+    "discrimination": "差別・ヘイト・誹謗中傷",
+    "crime": "違法行為の手引き",
+    "propaganda_conspiracy": "過激な政治・宗教プロパガンダ・陰謀論",
+    "spam": "スパム・詐欺・アダルト・違法コピー配布サイト由来",
+}
+
+MODE_CONFIGS: dict[str, dict[str, Any]] = {
+    "distinct_terms_3plus": {
+        "threshold": 3,
+        # カテゴリ別の上書き。crime は薬物名・手口名が報道や法律解説に並びやすいため5語以上にする。
+        "category_thresholds": {"crime": 5},
+        "criterion_ja": "同じカテゴリの異なる該当単語が3種類以上（crime は5種類以上、URLと本文の合計）ある文書を削除",
+    },
+}
+
+
+def category_threshold(config: dict[str, Any], category: str) -> int:
+    return int(config.get("category_thresholds", {}).get(category, config["threshold"]))
+
+
+def json_safe(value: Any) -> Any:
+    """JSONLに書ける基本型へ変換する。"""
+
+    if value is None or isinstance(value, (str, int, bool)):
+        return value
+    if isinstance(value, float):
+        return value if value == value and abs(value) != float("inf") else None
+    if isinstance(value, (list, tuple)):
+        return [json_safe(item) for item in value]
+    if isinstance(value, dict):
+        return {str(key): json_safe(item) for key, item in value.items()}
+    return str(value)
+
+
+@dataclass(frozen=True)
+class Wordlists:
+    """カテゴリ別の照合語と、その出典および除外された語。"""
+
+    terms: dict[str, list[str]]
+    sources: dict[str, dict[str, list[str]]]
+    excluded: dict[str, list[str]]
+
+
+def load_wordlists(
+    reference_dir: Path,
+    additional_dir: Path,
+    exclude_dir: Path | None = None,
+) -> Wordlists:
+    """referenceと追加リストを統合し、除外リストの語を取り除く。
+
+    正規化後に重複した語は一つにまとめる。``exclude_dir`` の
+    ``ja_<category>_exclude.txt`` にある語は、出典にかかわらず当該カテゴリの
+    照合対象から外す。汎用語による誤検出を、既存リストを書き換えずに
+    抑えるための仕組みである。実際に取り除いた語は ``excluded`` に残す。
+    """
+
+    terms_by_category: dict[str, list[str]] = {}
+    sources_by_category: dict[str, dict[str, list[str]]] = {}
+    excluded_by_category: dict[str, list[str]] = {}
+    for category in CATEGORIES:
+        source_terms: dict[str, set[str]] = defaultdict(set)
+        for source_name, directory in (("reference", reference_dir), ("additional", additional_dir)):
+            for term in _read_terms(directory / f"ja_{category}_keywords.txt"):
+                source_terms[term].add(source_name)
+        excluded: set[str] = set()
+        if exclude_dir is not None:
+            excluded = set(_read_terms(exclude_dir / f"ja_{category}_exclude.txt"))
+        excluded_by_category[category] = sorted(term for term in excluded if term in source_terms)
+        terms = sorted(
+            (term for term in source_terms if term not in excluded),
+            key=lambda term: (-len(term), term),
+        )
+        terms_by_category[category] = terms
+        sources_by_category[category] = {
+            term: sorted(source_terms[term]) for term in terms
+        }
+    return Wordlists(terms_by_category, sources_by_category, excluded_by_category)
+
+
+class KeywordMatcher:
+    """全カテゴリの語を一度の正規表現走査で数える。
+
+    本文は文字種境界付きで照合する。URLはドメインやパスが単語を区切りなしに
+    連結する（sexynews、hentaio など）ため境界なしで照合する。URL中の日本語は
+    パーセント符号化されているので、影響を受けるのはASCII語だけである。
+    """
+
+    def __init__(
+        self,
+        terms_by_category: dict[str, list[str]],
+        sources_by_category: dict[str, dict[str, list[str]]],
+    ) -> None:
+        self.sources_by_category = sources_by_category
+        term_categories: dict[str, list[str]] = defaultdict(list)
+        for category in CATEGORIES:
+            for term in terms_by_category[category]:
+                term_categories[term].append(category)
+        self.term_categories = {
+            term: tuple(categories) for term, categories in term_categories.items()
+        }
+        alternatives = sorted(self.term_categories, key=lambda term: (-len(term), term))
+        self.pattern = compile_trie_pattern(alternatives)
+        self.url_pattern = compile_trie_pattern(alternatives, boundaries=False)
+
+    def count_text(self, text: Any, pattern: re.Pattern[str] | None = None) -> Counter[tuple[str, str]]:
+        counts: Counter[tuple[str, str]] = Counter()
+        normalized = normalize(text)
+        if not normalized:
+            return counts
+        for found in (pattern or self.pattern).finditer(normalized):
+            term = found.group(0)
+            for category in self.term_categories[term]:
+                counts[(category, term)] += 1
+        return counts
+
+    def match_record(self, url: Any, content: Any) -> list[dict[str, Any]]:
+        url_counts = self.count_text(url, self.url_pattern)
+        content_counts = self.count_text(content)
+        total_counts = url_counts + content_counts
+        return [
+            {
+                "category": category,
+                "category_ja": CATEGORY_LABELS_JA[category],
+                "term": term,
+                "occurrences": occurrences,
+                "url_occurrences": url_counts[(category, term)],
+                "content_occurrences": content_counts[(category, term)],
+                "wordlist_sources": self.sources_by_category[category][term],
+            }
+            for (category, term), occurrences in sorted(
+                total_counts.items(),
+                key=lambda item: (CATEGORIES.index(item[0][0]), item[0][1]),
+            )
+        ]
+
+
+def _new_stats(
+    mode_name: str,
+    source_file: Path,
+    wordlist_counts: dict[str, int],
+) -> dict[str, Any]:
+    config = MODE_CONFIGS[mode_name]
+    return {
+        "filter_mode": mode_name,
+        "threshold": config["threshold"],
+        "category_thresholds": config.get("category_thresholds", {}),
+        "criterion_ja": config["criterion_ja"],
+        "source_file": str(source_file),
+        "wordlist_unique_terms_by_category": wordlist_counts,
+        "total_records_scanned": 0,
+        "records_with_any_keyword_match": 0,
+        "records_deleted": 0,
+        "records_retained": 0,
+        "deletion_rate": 0.0,
+        "records_deleted_by_reason": {"wordlist": 0, "domain_blocklist": 0, "cooccurrence": 0, "multiple_reasons": 0},
+        "domain_blocklist": {"enabled": False},
+        "cooccurrence": {"enabled": False},
+        "total_keyword_occurrences": 0,
+        "by_category": {
+            category: {
+                "label_ja": CATEGORY_LABELS_JA[category],
+                "records_with_match": 0,
+                "records_deleted": 0,
+                "keyword_occurrences": 0,
+                "distinct_terms_matched": 0,
+            }
+            for category in CATEGORIES
+        },
+        "top_matched_terms": [],
+        "term_statistics": [],
+    }
+
+
+def _distinct_terms_by_category(matches: list[dict[str, Any]]) -> dict[str, list[str]]:
+    terms_by_category: dict[str, set[str]] = {category: set() for category in CATEGORIES}
+    for item in matches:
+        terms_by_category[item["category"]].add(item["term"])
+    return {category: sorted(terms) for category, terms in terms_by_category.items() if terms}
+
+
+def _deleted_categories(
+    matches: list[dict[str, Any]],
+    threshold: int,
+    category_thresholds: dict[str, int] | None = None,
+) -> list[str]:
+    distinct = _distinct_terms_by_category(matches)
+    overrides = category_thresholds or {}
+    return [
+        category for category in CATEGORIES
+        if len(distinct.get(category, ())) >= int(overrides.get(category, threshold))
+    ]
+
+
+def _update_stats(
+    stats: dict[str, Any],
+    matches: list[dict[str, Any]],
+    deleted_categories: list[str],
+    term_record_counts: Counter[tuple[str, str]],
+    term_occurrence_counts: Counter[tuple[str, str]],
+) -> None:
+    if not matches:
+        return
+    stats["records_with_any_keyword_match"] += 1
+    total_occurrences = sum(item["occurrences"] for item in matches)
+    stats["total_keyword_occurrences"] += total_occurrences
+    for category in {item["category"] for item in matches}:
+        category_items = [item for item in matches if item["category"] == category]
+        category_stats = stats["by_category"][category]
+        category_stats["records_with_match"] += 1
+        category_stats["keyword_occurrences"] += sum(item["occurrences"] for item in category_items)
+        if category in deleted_categories:
+            category_stats["records_deleted"] += 1
+    for item in matches:
+        key = (item["category"], item["term"])
+        term_record_counts[key] += 1
+        term_occurrence_counts[key] += item["occurrences"]
+
+
+def _finalize_stats(
+    stats: dict[str, Any],
+    term_record_counts: Counter[tuple[str, str]],
+    term_occurrence_counts: Counter[tuple[str, str]],
+) -> None:
+    total = stats["total_records_scanned"]
+    stats["records_retained"] = total - stats["records_deleted"]
+    stats["deletion_rate"] = stats["records_deleted"] / total if total else 0.0
+    stats["term_statistics"] = [
+        {
+            "category": category,
+            "category_ja": CATEGORY_LABELS_JA[category],
+            "term": term,
+            "records_with_match": term_record_counts[(category, term)],
+            "keyword_occurrences": term_occurrence_counts[(category, term)],
+        }
+        for category, term in sorted(term_record_counts, key=lambda key: (CATEGORIES.index(key[0]), key[1]))
+    ]
+    for category in CATEGORIES:
+        stats["by_category"][category]["distinct_terms_matched"] = sum(
+            1 for item in stats["term_statistics"] if item["category"] == category
+        )
+    stats["top_matched_terms"] = sorted(
+        stats["term_statistics"],
+        key=lambda item: (-item["records_with_match"], -item["keyword_occurrences"], item["category"], item["term"]),
+    )[:100]
+
+
+def _new_blocklist_stats(blocklist: DomainBlocklist) -> dict[str, Any]:
+    return {
+        "enabled": True,
+        "sources": blocklist.manifest(),
+        "records_matched": 0,
+        "records_deleted": 0,
+        "records_flagged_only": 0,
+        "by_source": {
+            source["name"]: {"action": source["action"], "records_matched": 0, "records_deleted": 0}
+            for source in blocklist.manifest()
+        },
+    }
+
+
+def _new_cooccurrence_stats(detector: CooccurrenceDetector) -> dict[str, Any]:
+    return {
+        "enabled": True,
+        "rules": detector.describe(),
+        "records_matched": 0,
+        "records_deleted": 0,
+        "by_rule": {
+            rule["name"]: {
+                "label_ja": rule["label_ja"],
+                "category": rule["category"],
+                "records_matched": 0,
+                "pair_counts": Counter(),
+            }
+            for rule in detector.describe()
+        },
+    }
+
+
+REASON_LABELS_JA = {
+    "wordlist": "ワードリスト（同一カテゴリ3語以上）",
+    "domain_blocklist": "URLのドメインがブロックリストに一致",
+    "cooccurrence": "近接共起規則（未成年×性的文脈、違法物×手引き）",
+}
+
+
+def run_toxic_filters(
+    input_path: Path,
+    output_root: Path,
+    reference_dir: Path,
+    additional_dir: Path,
+    batch_size: int = 2048,
+    modes: Iterable[str] | None = None,
+    start_row: int = 0,
+    max_rows: int | None = None,
+    exclude_dir: Path | None = None,
+    blocklist: DomainBlocklist | None = None,
+    cooccurrence: CooccurrenceDetector | None = None,
+) -> dict[str, Any]:
+    """指定モードの有害コンテンツフィルタを一度の走査で実行する。
+
+    削除条件は3系統ある。(1) ワードリストの同一カテゴリ3語以上、(2) URLの
+    ドメインブロックリスト、(3) 近接共起規則。(2)(3) はモードに依存せず
+    全モードで同じ判定になる。共起規則の一致は全件を
+    ``cooccurrence_review.jsonl`` に、ブロックリストの記録のみ一致は
+    ``flagged.jsonl`` に書き出す。
+    """
+
+    selected_modes = list(modes) if modes is not None else list(MODE_CONFIGS)
+    unknown = [mode for mode in selected_modes if mode not in MODE_CONFIGS]
+    if unknown:
+        raise ValueError(f"未知のモード: {', '.join(unknown)}")
+    if not selected_modes:
+        raise ValueError("少なくとも1つのモードを指定してください")
+
+    wordlists = load_wordlists(reference_dir, additional_dir, exclude_dir)
+    wordlist_counts = {category: len(wordlists.terms[category]) for category in CATEGORIES}
+    matcher = KeywordMatcher(wordlists.terms, wordlists.sources)
+    output_dirs = {mode: output_root / mode for mode in selected_modes}
+    for directory in output_dirs.values():
+        directory.mkdir(parents=True, exist_ok=True)
+    parquet = pq.ParquetFile(input_path)
+    schema = parquet.schema_arrow
+    writers = {
+        mode: pq.ParquetWriter(directory / "retained.parquet", schema, compression="zstd")
+        for mode, directory in output_dirs.items()
+    }
+    handles = {
+        mode: (directory / "removed.jsonl").open("w", encoding="utf-8", newline="\n")
+        for mode, directory in output_dirs.items()
+    }
+    review_handles = {
+        mode: (directory / "cooccurrence_review.jsonl").open("w", encoding="utf-8", newline="\n")
+        for mode, directory in output_dirs.items()
+    } if cooccurrence is not None else {}
+    flagged_handles = {
+        mode: (directory / "flagged.jsonl").open("w", encoding="utf-8", newline="\n")
+        for mode, directory in output_dirs.items()
+    } if blocklist is not None else {}
+    borderline_handles = {
+        mode: (directory / "borderline.jsonl").open("w", encoding="utf-8", newline="\n")
+        for mode, directory in output_dirs.items()
+    }
+    stats_by_mode = {mode: _new_stats(mode, input_path, wordlist_counts) for mode in selected_modes}
+    for stats in stats_by_mode.values():
+        if blocklist is not None:
+            stats["domain_blocklist"] = _new_blocklist_stats(blocklist)
+        if cooccurrence is not None:
+            stats["cooccurrence"] = _new_cooccurrence_stats(cooccurrence)
+    record_counts = {mode: Counter() for mode in selected_modes}
+    occurrence_counts = {mode: Counter() for mode in selected_modes}
+    scanned_at = datetime.now(timezone.utc).isoformat()
+    stop_row = start_row + max_rows if max_rows is not None else None
+    row_offset = 0
+    scanned = 0
+    try:
+        for source_batch in parquet.iter_batches(batch_size=batch_size):
+            source_start = row_offset
+            row_offset += source_batch.num_rows
+            if row_offset <= start_row:
+                continue
+            if stop_row is not None and source_start >= stop_row:
+                break
+            local_start = max(0, start_row - source_start)
+            local_end = source_batch.num_rows if stop_row is None else min(source_batch.num_rows, stop_row - source_start)
+            batch = source_batch.slice(local_start, local_end - local_start)
+            rows = batch.to_pylist()
+            retained_indices = {mode: [] for mode in selected_modes}
+            for row_index, row in enumerate(rows):
+                url = row.get("url") or ""
+                content = row.get("content") or ""
+                record_index = start_row + scanned
+                scanned += 1
+                matches = matcher.match_record(url, content)
+                domain_matches = blocklist.match(url) if blocklist is not None else []
+                domain_delete = any(item["action"] == "delete" for item in domain_matches)
+                cooccurrence_matches = cooccurrence.detect(content) if cooccurrence is not None else []
+                for mode in selected_modes:
+                    config = MODE_CONFIGS[mode]
+                    deleted_categories = _deleted_categories(matches, config["threshold"], config.get("category_thresholds"))
+                    reasons = []
+                    if deleted_categories:
+                        reasons.append("wordlist")
+                    if domain_delete:
+                        reasons.append("domain_blocklist")
+                    if cooccurrence_matches:
+                        reasons.append("cooccurrence")
+                    deleted = bool(reasons)
+                    stats = stats_by_mode[mode]
+                    stats["total_records_scanned"] += 1
+                    _update_stats(stats, matches, deleted_categories, record_counts[mode], occurrence_counts[mode])
+                    if domain_matches:
+                        block_stats = stats["domain_blocklist"]
+                        block_stats["records_matched"] += 1
+                        if deleted:
+                            block_stats["records_deleted"] += 1
+                        elif not domain_delete:
+                            block_stats["records_flagged_only"] += 1
+                        for source_name in {item["source"] for item in domain_matches}:
+                            block_stats["by_source"][source_name]["records_matched"] += 1
+                            if deleted:
+                                block_stats["by_source"][source_name]["records_deleted"] += 1
+                    if cooccurrence_matches:
+                        cooc_stats = stats["cooccurrence"]
+                        cooc_stats["records_matched"] += 1
+                        cooc_stats["records_deleted"] += 1
+                        for item in cooccurrence_matches:
+                            rule_stats = cooc_stats["by_rule"][item["rule"]]
+                            rule_stats["records_matched"] += 1
+                            for pair in item["pairs"]:
+                                rule_stats["pair_counts"][f"{pair['a']}|{pair['b']}"] += 1
+                            review_handles[mode].write(json.dumps({
+                                "record_index": record_index,
+                                "url": json_safe(url),
+                                "rule": item["rule"],
+                                "label_ja": item["label_ja"],
+                                "pair_count": item["pair_count"],
+                                "pairs": item["pairs"],
+                                "excerpt": item["excerpt"],
+                                "reviewer": "",
+                                "verdict": "",
+                                "reason": "",
+                            }, ensure_ascii=False, separators=(",", ":")) + "\n")
+                    if deleted:
+                        stats["records_deleted"] += 1
+                        for reason in reasons:
+                            stats["records_deleted_by_reason"][reason] += 1
+                        if len(reasons) > 1:
+                            stats["records_deleted_by_reason"]["multiple_reasons"] += 1
+                        output_record = {str(key): json_safe(value) for key, value in row.items()}
+                        output_record.update(
+                            {
+                                "_filter_deleted": True,
+                                "_filter_mode": mode,
+                                "_filter_threshold": config["threshold"],
+                                "_filter_deleted_by": reasons,
+                                "_filter_reason": "；".join(REASON_LABELS_JA[reason] for reason in reasons),
+                                "_filter_deleted_categories": deleted_categories,
+                                "_filter_distinct_matched_terms_by_category": {
+                                    category: sorted({item["term"] for item in matches if item["category"] == category})
+                                    for category in deleted_categories
+                                },
+                                "_filter_matched_terms": matches,
+                                "_filter_total_keyword_occurrences": sum(item["occurrences"] for item in matches),
+                                "_filter_domain_matches": domain_matches,
+                                "_filter_cooccurrence_matches": cooccurrence_matches,
+                                "_filter_record_index": record_index,
+                                "_filter_method": "wordlist_toxic_filter_v4",
+                                "_filter_source_file": str(input_path),
+                                "_filter_scanned_at_utc": scanned_at,
+                            }
+                        )
+                        handles[mode].write(json.dumps(output_record, ensure_ascii=False, separators=(",", ":")) + "\n")
+                    else:
+                        borderline = {
+                            category: terms
+                            for category, terms in _distinct_terms_by_category(matches).items()
+                            if len(terms) == category_threshold(config, category) - 1
+                        }
+                        if borderline:
+                            borderline_handles[mode].write(json.dumps({
+                                "record_index": record_index,
+                                "url": json_safe(url),
+                                "categories": borderline,
+                            }, ensure_ascii=False, separators=(",", ":")) + "\n")
+                        if domain_matches:
+                            flagged_handles[mode].write(json.dumps({
+                                "record_index": record_index,
+                                "url": json_safe(url),
+                                "domain_matches": domain_matches,
+                            }, ensure_ascii=False, separators=(",", ":")) + "\n")
+                        retained_indices[mode].append(row_index)
+            for mode in selected_modes:
+                if retained_indices[mode]:
+                    writers[mode].write_batch(batch.take(pa.array(retained_indices[mode], type=pa.int64())))
+    finally:
+        for writer in writers.values():
+            writer.close()
+        for handle in (
+            list(handles.values()) + list(review_handles.values())
+            + list(flagged_handles.values()) + list(borderline_handles.values())
+        ):
+            handle.close()
+
+    for mode, stats in stats_by_mode.items():
+        _finalize_stats(stats, record_counts[mode], occurrence_counts[mode])
+        if stats["cooccurrence"].get("enabled"):
+            for rule_stats in stats["cooccurrence"]["by_rule"].values():
+                rule_stats["pair_counts"] = [
+                    {"pair": pair, "records": count} for pair, count in rule_stats["pair_counts"].most_common(30)
+                ]
+        stats.update(
+            {
+                "scanned_at_utc": scanned_at,
+                "input_schema": list(schema.names),
+                "row_range": {
+                    "start_row_inclusive": start_row,
+                    "end_row_exclusive": start_row + stats["total_records_scanned"],
+                },
+                "removed_jsonl": str(output_dirs[mode] / "removed.jsonl"),
+                "retained_parquet": str(output_dirs[mode] / "retained.parquet"),
+                "cooccurrence_review_jsonl": str(output_dirs[mode] / "cooccurrence_review.jsonl") if cooccurrence is not None else None,
+                "flagged_jsonl": str(output_dirs[mode] / "flagged.jsonl") if blocklist is not None else None,
+                "borderline_jsonl": str(output_dirs[mode] / "borderline.jsonl"),
+                "wordlist_reference_dir": str(reference_dir),
+                "wordlist_additional_dir": str(additional_dir),
+                "wordlist_exclude_dir": str(exclude_dir) if exclude_dir is not None else None,
+                "wordlist_excluded_terms_by_category": wordlists.excluded,
+                "wordlist_matching_scope": "url + content",
+                "matching_normalization": "NFKC then lowercase",
+                "same_position_partial_match_policy": "longest match first",
+                "matching_boundary_policy": "content: ASCII edge requires no adjacent [a-z0-9], katakana edge requires no adjacent katakana, kanji/hiragana edge none; url: no boundaries",
+                "deletion_reasons_ja": REASON_LABELS_JA,
+                "note_ja": "候補語・ブロックリスト・共起規則による機械的な監査結果。最終除外前に文脈と誤検出を確認すること。",
+            }
+        )
+        (output_dirs[mode] / "summary.json").write_text(json.dumps(stats, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+
+    combined = {
+        "source_file": str(input_path),
+        "scanned_at_utc": scanned_at,
+        "wordlist_reference_dir": str(reference_dir),
+        "wordlist_additional_dir": str(additional_dir),
+        "wordlist_exclude_dir": str(exclude_dir) if exclude_dir is not None else None,
+        "wordlist_excluded_terms_by_category": wordlists.excluded,
+        "wordlist_unique_terms_by_category": wordlist_counts,
+        "domain_blocklist_sources": blocklist.manifest() if blocklist is not None else None,
+        "cooccurrence_rules": cooccurrence.describe() if cooccurrence is not None else None,
+        "row_range": {
+            "start_row_inclusive": start_row,
+            "end_row_exclusive": start_row + next(iter(stats_by_mode.values()))["total_records_scanned"],
+        },
+        "modes": {mode: stats_by_mode[mode] for mode in selected_modes},
+    }
+    output_root.mkdir(parents=True, exist_ok=True)
+    (output_root / "summary.json").write_text(json.dumps(combined, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+    return combined
+
+
+# 既存コードから呼び出す場合の簡潔な別名。
+run_filter = run_toxic_filters

code/e5cb5ca/src/hf_jobs_launch.py

@@ -0,0 +1,227 @@
+"""HF Jobs で全シャードのクレンジングを実行するランチャー。
+
+``common_crawl_0`` 〜 ``common_crawl_18`` の各ディレクトリを1ジョブにし、次を行う。
+
+* 入力データセット（``Podtech/abeja-cc-ja-filtered``）を ``/data`` にマウント（ダウンロード不要）
+* このリポジトリの ``src/`` と UT1 ブロックリストのキャッシュを、出力用の非公開データセットへ
+  ``code/<ref>/src`` と ``blocklists/ut1`` として1回だけアップロードし、各ジョブがそこから取得する
+  （全ジョブが同じコード・同じリストで動くことをマニフェストで保証する）
+* ``HF_TOKEN`` はシークレットとして渡す（ログに出ない）
+* ``run_shard.py`` を ``--upload-repo`` 付きで実行し、出力は ``outputs/common_crawl_N/<shard>/`` へ
+  シャード単位でアップロードして一時ディスクから削除する
+* タイムアウトは既定の30分ではなく ``--timeout``（既定 6h）を指定する
+
+    uv run --env-file .env python abeja-cc-ja/src/hf_jobs_launch.py --dirs 0 --limit-shards 2 --dry-run
+    uv run --env-file .env python abeja-cc-ja/src/hf_jobs_launch.py --dirs 0 --limit-shards 2
+    uv run --env-file .env python abeja-cc-ja/src/hf_jobs_launch.py --dirs 0-18 --policy-approver "<名前>" --policy-approved-on 2026-09-04
+
+完了後は ``aggregate_summaries.py --repo <出力repo> --prefix outputs --expected-inputs <入力repo>`` で集約する。
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+import shlex
+import subprocess
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+
+DEFAULT_INPUT = "Podtech/abeja-cc-ja-filtered"
+DEFAULT_OUTPUT = "Podtech/abeja-cc-ja-cleaned"
+DEFAULT_IMAGE = "python:3.12"
+DEFAULT_FLAVOR = "cpu-upgrade"
+DEFAULT_TIMEOUT = "6h"
+CODE_IGNORE = ["__pycache__/**", "*.pyc", ".pytest_cache/**", "test_*.py", "*.md"]
+
+
+def parse_dirs(spec: str) -> list[int]:
+    result: list[int] = []
+    for part in spec.split(","):
+        part = part.strip()
+        if "-" in part:
+            low, high = part.split("-", 1)
+            result.extend(range(int(low), int(high) + 1))
+        elif part:
+            result.append(int(part))
+    return sorted(set(result))
+
+
+def code_ref(code_dir: Path) -> str:
+    """git のコミット短縮ハッシュ（未コミット変更があれば -dirty と内容ハッシュ）。"""
+
+    try:
+        sha = subprocess.check_output(["git", "rev-parse", "--short", "HEAD"], cwd=code_dir, text=True).strip()
+        dirty = subprocess.check_output(["git", "status", "--porcelain", "--", "."], cwd=code_dir, text=True).strip() != ""
+    except Exception:  # noqa: BLE001
+        sha, dirty = "nogit", True
+    if not dirty:
+        return sha
+    digest = hashlib.sha256()
+    for path in sorted(code_dir.rglob("*")):
+        if path.is_file() and "__pycache__" not in path.parts and not path.name.startswith("test_"):
+            digest.update(path.relative_to(code_dir).as_posix().encode())
+            digest.update(path.read_bytes())
+    return f"{sha}-dirty-{digest.hexdigest()[:8]}"
+
+
+def build_job_script(output_repo: str, ref: str, dir_index: int, args: argparse.Namespace) -> str:
+    input_dir = f"/data/data/common_crawl_{dir_index}"
+    run_args = [
+        "--input-dir", input_dir,
+        "--output-root", f"/work/out/common_crawl_{dir_index}",
+        "--blocklist-cache-dir", "/work/repo/blocklists/ut1",
+        "--upload-repo", output_repo,
+        "--upload-prefix", f"outputs/common_crawl_{dir_index}",
+        "--upload-batch", str(args.upload_batch),
+        "--delete-local-after-upload",
+        "--skip-existing-in-repo",
+    ]
+    if args.limit_shards is not None:
+        run_args += ["--limit-shards", str(args.limit_shards)]
+    if args.policy_approver:
+        run_args += ["--policy-approver", args.policy_approver]
+    if args.policy_approved_on:
+        run_args += ["--policy-approved-on", args.policy_approved_on]
+    if args.policy_note:
+        run_args += ["--policy-note", args.policy_note]
+    workers_expr = str(args.workers) if args.workers else '"$(( ${CPU_CORES:-2} > 1 ? ${CPU_CORES:-2} - 1 : 1 ))"'
+    snapshot = (
+        "from huggingface_hub import snapshot_download; "
+        f"snapshot_download({output_repo!r}, repo_type='dataset', local_dir='/work/repo', "
+        f"allow_patterns=['code/{ref}/**', 'blocklists/ut1/**'])"
+    )
+    lines = [
+        "set -euo pipefail",
+        "export PIP_DISABLE_PIP_VERSION_CHECK=1 PYTHONUNBUFFERED=1",
+        'pip install -q "pyarrow>=17" "huggingface_hub>=1.0" "sudachipy>=0.6" "sudachidict_core"',
+        "mkdir -p /work/out && cd /work",
+        f"python -c {shlex.quote(snapshot)}",
+        f"ls /work/repo/code/{ref}/src >/dev/null",
+        f"test -f /work/repo/blocklists/ut1/manifest.json",
+        # pipefail 下で `ls | head` は SIGPIPE で失敗し得るため、件数だけを表示する
+        f'echo "input shards: $(ls {input_dir} | wc -l)"',
+        f"python /work/repo/code/{ref}/src/run_shard.py " + " ".join(shlex.quote(a) for a in run_args) + f" --workers {workers_expr}",
+    ]
+    return "\n".join(lines) + "\n"
+
+
+def upload_code_and_blocklists(api, output_repo: str, code_dir: Path, ref: str, ut1_cache_dir: Path, dry_run: bool) -> dict[str, Any]:
+    existing = set(api.list_repo_files(output_repo, repo_type="dataset")) if not dry_run else set()
+    code_prefix = f"code/{ref}/src"
+    files = sorted(p for p in code_dir.rglob("*") if p.is_file() and "__pycache__" not in p.parts and not p.name.startswith("test_") and not p.name.endswith(".pyc"))
+    manifest = {
+        "ref": ref,
+        "uploaded_at_utc": datetime.now(timezone.utc).isoformat(),
+        "files": {p.relative_to(code_dir).as_posix(): hashlib.sha256(p.read_bytes()).hexdigest() for p in files},
+    }
+    actions: dict[str, Any] = {"code_prefix": code_prefix, "code_files": len(files), "ref": ref}
+    if dry_run:
+        actions["code_upload"] = "dry-run"
+    elif f"{code_prefix}/run_shard.py" in existing:
+        actions["code_upload"] = "already present"
+    else:
+        api.upload_folder(repo_id=output_repo, repo_type="dataset", folder_path=str(code_dir), path_in_repo=code_prefix,
+                          ignore_patterns=CODE_IGNORE, commit_message=f"code {ref}")
+        api.upload_file(repo_id=output_repo, repo_type="dataset", path_or_fileobj=json.dumps(manifest, ensure_ascii=False, indent=2).encode("utf-8"),
+                        path_in_repo=f"code/{ref}/MANIFEST.json", commit_message=f"code manifest {ref}")
+        actions["code_upload"] = "uploaded"
+    if not (ut1_cache_dir / "manifest.json").exists():
+        raise FileNotFoundError(f"UT1 キャッシュがありません: {ut1_cache_dir}（domain_blocklist.py fetch を先に実行）")
+    if dry_run:
+        actions["blocklist_upload"] = "dry-run"
+    elif "blocklists/ut1/manifest.json" in existing:
+        actions["blocklist_upload"] = "already present"
+    else:
+        api.upload_folder(repo_id=output_repo, repo_type="dataset", folder_path=str(ut1_cache_dir), path_in_repo="blocklists/ut1",
+                          commit_message="UT1 blocklists snapshot")
+        actions["blocklist_upload"] = "uploaded"
+    return actions
+
+
+def main(argv: list[str] | None = None) -> None:
+    source_dir = Path(__file__).resolve().parent
+    project_root = source_dir.parent
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--input-dataset", default=DEFAULT_INPUT)
+    parser.add_argument("--output-repo", default=DEFAULT_OUTPUT, help="非公開で作成される出力データセット")
+    parser.add_argument("--dirs", default="0-18", help="例: 0-18, 0,1,2")
+    parser.add_argument("--flavor", default=DEFAULT_FLAVOR)
+    parser.add_argument("--timeout", default=DEFAULT_TIMEOUT, help="例: 6h, 90m")
+    parser.add_argument("--image", default=DEFAULT_IMAGE)
+    parser.add_argument("--namespace", default=None, help="課金先。既定は出力リポジトリの所有者")
+    parser.add_argument("--workers", type=int, default=None, help="既定はジョブ内の CPU_CORES - 1")
+    parser.add_argument("--upload-batch", type=int, default=5)
+    parser.add_argument("--limit-shards", type=int, default=None, help="各ディレクトリの先頭N件だけ（試運転用）")
+    parser.add_argument("--policy-approver", default=None)
+    parser.add_argument("--policy-approved-on", default=None)
+    parser.add_argument("--policy-note", default=None)
+    parser.add_argument("--code-dir", type=Path, default=source_dir)
+    parser.add_argument("--ut1-cache-dir", type=Path, default=project_root / "data" / "blocklists" / "ut1")
+    parser.add_argument("--dry-run", action="store_true", help="ジョブ定義とスクリプトを表示するだけで起動しない")
+    parser.add_argument("--wait", action="store_true", help="全ジョブの終了を待つ")
+    args = parser.parse_args(argv)
+
+    token = os.environ.get("HF_TOKEN")
+    if not token and not args.dry_run:
+        raise SystemExit("HF_TOKEN が未設定です（uv run --env-file .env ...）")
+    dirs = parse_dirs(args.dirs)
+    ref = code_ref(args.code_dir)
+    namespace = args.namespace or args.output_repo.split("/")[0]
+
+    from huggingface_hub import HfApi, Volume
+
+    api = HfApi(token=token)
+    if not args.dry_run:
+        api.create_repo(args.output_repo, repo_type="dataset", private=True, exist_ok=True)
+    actions = upload_code_and_blocklists(api, args.output_repo, args.code_dir, ref, args.ut1_cache_dir, args.dry_run)
+    print(json.dumps({"event": "prepared", **actions, "output_repo": args.output_repo, "private": True}, ensure_ascii=False), flush=True)
+
+    launched: list[dict[str, Any]] = []
+    for dir_index in dirs:
+        script = build_job_script(args.output_repo, ref, dir_index, args)
+        spec = {
+            "name": f"abeja-cc-ja-clean-{dir_index}",
+            "image": args.image,
+            "flavor": args.flavor,
+            "timeout": args.timeout,
+            "namespace": namespace,
+            "volumes": [{"type": "dataset", "source": args.input_dataset, "mount_path": "/data", "read_only": True}],
+            "secrets": ["HF_TOKEN"],
+            "labels": {"pipeline": "abeja-cc-ja-cleansing", "dir": f"common_crawl_{dir_index}", "code_ref": ref},
+        }
+        if args.dry_run:
+            print(json.dumps({"event": "dry-run", "job": spec}, ensure_ascii=False))
+            print("--- script ---\n" + script)
+            continue
+        job = api.run_job(
+            image=args.image,
+            command=["bash", "-lc", script],
+            flavor=args.flavor,
+            timeout=args.timeout,
+            secrets={"HF_TOKEN": token},
+            env={"PIPELINE_DIR": f"common_crawl_{dir_index}"},
+            volumes=[Volume(type="dataset", source=args.input_dataset, mount_path="/data", read_only=True)],
+            namespace=namespace,
+            name=spec["name"],
+            labels=spec["labels"],
+        )
+        launched.append({"dir": dir_index, "job_id": job.id, "url": job.url})
+        print(json.dumps({"event": "launched", "dir": dir_index, "job_id": job.id, "url": job.url}), flush=True)
+    if launched:
+        record = project_root / "data" / f"hf_jobs_{datetime.now(timezone.utc).strftime('%Y%m%dT%H%M%SZ')}.json"
+        record.parent.mkdir(parents=True, exist_ok=True)
+        record.write_text(json.dumps({"ref": ref, "output_repo": args.output_repo, "jobs": launched, "flavor": args.flavor, "timeout": args.timeout}, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+        print(json.dumps({"event": "recorded", "file": str(record)}), flush=True)
+    if args.wait and launched:
+        finished = api.wait_for_job(job_id=[j["job_id"] for j in launched])
+        for info in (finished if isinstance(finished, list) else [finished]):
+            print(json.dumps({"event": "finished", "job_id": info.id, "stage": info.status.stage, "message": info.status.message}), flush=True)
+
+
+if __name__ == "__main__":
+    main()

code/e5cb5ca/src/main_pii.py

@@ -0,0 +1,63 @@
+"""PII置換フィルタの実行入口と既定コンフィグ。"""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+from filter_pii import run_filter
+
+
+PROJECT_ROOT = Path(__file__).resolve().parents[1]
+DEFAULT_CONFIG = {
+    "input": PROJECT_ROOT / "data" / "raw" / "common_crawl_0_filtered_0001.parquet",
+    "output_root": PROJECT_ROOT / "data" / "check_ver2" / "pii_0001_replaced_final",
+    "batch_size": 2048,
+}
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--input", type=Path, default=DEFAULT_CONFIG["input"])
+    parser.add_argument("--output-root", type=Path, default=DEFAULT_CONFIG["output_root"])
+    parser.add_argument("--batch-size", type=int, default=DEFAULT_CONFIG["batch_size"])
+    parser.add_argument("--start-row", type=int, default=0)
+    parser.add_argument("--max-rows", type=int, default=None)
+    parser.add_argument("--policy-approver", default=None, help="処理方針（置換）の承認者名。summary.json の pii_policy に記録される。")
+    parser.add_argument("--policy-approved-on", default=None, help="承認日（YYYY-MM-DD）。")
+    parser.add_argument("--policy-note", default=None, help="方針の補足（任意）。")
+    parser.add_argument("--mask-honorific-names", action="store_true", help="「○○さん／氏／様」だけの姓名も置換する。")
+    parser.add_argument("--mask-bare-names", action="store_true", help="文脈の無い姓名も置換する。")
+    parser.add_argument("--no-affiliation-titles", dest="affiliation_titles", action="store_false", help="役職語（代表取締役、教授等）だけの文脈を所属とみなさない（組織名のみに狭める）。")
+    args = parser.parse_args(argv)
+    if not args.input.exists():
+        raise FileNotFoundError(args.input)
+    summary = run_filter(
+        input_path=args.input,
+        output_root=args.output_root,
+        batch_size=args.batch_size,
+        start_row=args.start_row,
+        max_rows=args.max_rows,
+        policy_approver=args.policy_approver,
+        policy_approved_on=args.policy_approved_on,
+        policy_note=args.policy_note,
+        mask_honorific_names=args.mask_honorific_names,
+        mask_bare_names=args.mask_bare_names,
+        affiliation_titles=args.affiliation_titles,
+    )
+    print(json.dumps({
+        "row_range": summary["row_range"],
+        "total_records_scanned": summary["total_records_scanned"],
+        "records_with_replacement": summary["records_with_replacement"],
+        "records_changed": summary["records_changed"],
+        "records_unchanged": summary["records_unchanged"],
+        "total_replacements": summary["total_replacements"],
+        "by_type": {k: v["replacement_count"] for k, v in summary["by_type"].items()},
+        "pii_policy_status": summary["pii_policy"]["status"],
+    }, ensure_ascii=False))
+
+
+if __name__ == "__main__":
+    main()
+

code/e5cb5ca/src/main_toxic.py

@@ -0,0 +1,86 @@
+"""有害コンテンツフィルタの実行入口と既定コンフィグ。"""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+from cooccurrence import CooccurrenceDetector, load_rules
+from domain_blocklist import DomainBlocklist
+from filter_toxic import MODE_CONFIGS, run_toxic_filters
+
+
+PROJECT_ROOT = Path(__file__).resolve().parents[1]
+SOURCE_DIR = Path(__file__).resolve().parent
+DEFAULT_CONFIG = {
+    "input": PROJECT_ROOT / "data" / "raw" / "common_crawl_0_filtered_0001.parquet",
+    "output_root": PROJECT_ROOT / "data" / "check_ver2" / "toxic_0001",
+    "reference_dir": SOURCE_DIR / "wordlists" / "reference",
+    "additional_dir": SOURCE_DIR / "wordlists",
+    "exclude_dir": SOURCE_DIR / "wordlists" / "exclude",
+    "blocklist_dir": SOURCE_DIR / "blocklists",
+    "blocklist_cache_dir": PROJECT_ROOT / "data" / "blocklists" / "ut1",
+    "cooccurrence_rules": SOURCE_DIR / "wordlists" / "cooccurrence" / "rules.json",
+    "batch_size": 2048,
+    "modes": tuple(MODE_CONFIGS),
+}
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--input", type=Path, default=DEFAULT_CONFIG["input"])
+    parser.add_argument("--output-root", type=Path, default=DEFAULT_CONFIG["output_root"])
+    parser.add_argument("--reference-dir", type=Path, default=DEFAULT_CONFIG["reference_dir"])
+    parser.add_argument("--additional-dir", type=Path, default=DEFAULT_CONFIG["additional_dir"])
+    parser.add_argument("--exclude-dir", type=Path, default=DEFAULT_CONFIG["exclude_dir"],
+                        help="カテゴリ別除外リスト（ja_<category>_exclude.txt）のディレクトリ。")
+    parser.add_argument("--blocklist-dir", type=Path, default=DEFAULT_CONFIG["blocklist_dir"],
+                        help="ドメインブロックリストの設定・自前リストのディレクトリ。")
+    parser.add_argument("--blocklist-cache-dir", type=Path, default=DEFAULT_CONFIG["blocklist_cache_dir"],
+                        help="UT1リストの取得先（domain_blocklist.py fetch --dest で作成）。")
+    parser.add_argument("--no-blocklist", action="store_true", help="ドメインブロックリスト判定を無効にする。")
+    parser.add_argument("--cooccurrence-rules", type=Path, default=DEFAULT_CONFIG["cooccurrence_rules"],
+                        help="近接共起規則の定義JSON。")
+    parser.add_argument("--no-cooccurrence", action="store_true", help="近接共起規則を無効にする。")
+    parser.add_argument("--batch-size", type=int, default=DEFAULT_CONFIG["batch_size"])
+    parser.add_argument("--mode", choices=("all", *MODE_CONFIGS), action="append", default=None,
+                        help="実行モード。省略時は同一カテゴリ3語以上条件を実行。")
+    parser.add_argument("--start-row", type=int, default=0)
+    parser.add_argument("--max-rows", type=int, default=None)
+    args = parser.parse_args(argv)
+    for path in (args.input, args.reference_dir, args.additional_dir, args.exclude_dir):
+        if not path.exists():
+            raise FileNotFoundError(path)
+    modes = list(MODE_CONFIGS) if not args.mode or "all" in args.mode else args.mode
+    blocklist = None if args.no_blocklist else DomainBlocklist.load(args.blocklist_dir, args.blocklist_cache_dir)
+    cooccurrence = None if args.no_cooccurrence else CooccurrenceDetector(load_rules(args.cooccurrence_rules))
+    summary = run_toxic_filters(
+        input_path=args.input,
+        output_root=args.output_root,
+        reference_dir=args.reference_dir,
+        additional_dir=args.additional_dir,
+        batch_size=args.batch_size,
+        modes=modes,
+        start_row=args.start_row,
+        max_rows=args.max_rows,
+        exclude_dir=args.exclude_dir,
+        blocklist=blocklist,
+        cooccurrence=cooccurrence,
+    )
+    print(json.dumps({
+        "row_range": summary["row_range"],
+        "modes": {
+            mode: {
+                "total_records_scanned": values["total_records_scanned"],
+                "records_deleted": values["records_deleted"],
+                "records_retained": values["records_retained"],
+                "records_deleted_by_reason": values["records_deleted_by_reason"],
+            }
+            for mode, values in summary["modes"].items()
+        },
+    }, ensure_ascii=False))
+
+
+if __name__ == "__main__":
+    main()

code/e5cb5ca/src/pii_detector.py

@@ -0,0 +1,597 @@
+"""日本語Web文書向けのPII検出・置換器。
+
+``PII_detect.md`` の検出方針を踏まえ、正規表現・チェックデジットに加えて
+SudachiPy（形態素解析、人名辞書付き）で自然文中の氏名を検出する。学習済み
+NER（GLiNER-ja）は全件処理には重いため ``pii_residual_check.py`` の残存確認に
+使う。公開用データでは、検出した値を削除するのではなく、種別ごとの
+プレースホルダーへ置換する。対象は次の7種類に限定する。
+
+* 電話番号
+* メールアドレス
+* 番地レベルの住所
+* 個人名と所属の組合せ
+* マイナンバー
+* クレジットカード番号
+* 銀行口座番号
+
+郵便番号だけ、IPアドレス、秘密情報、生年月日などは対象外とする。個人名
+だけは「氏名：」等のラベル文脈に限って置換する。番号系（マイナンバー、
+カード、口座）はURLでは検出せず、本文でもラベル文脈か区切り書式を必須にする
+（無作為な数字列の1割はチェックデジットを通るため）。将来 fuseji、GLiNER-ja、GiNZA 等を追加する場合は
+``PIIDetector`` の結果へ検出結果を追加できる。
+"""
+
+from __future__ import annotations
+
+import re
+import unicodedata
+from dataclasses import dataclass
+from typing import Any, Iterable
+
+
+PII_LABELS_JA = {
+    "email": "メールアドレス",
+    "phone": "電話番号",
+    "address": "番地レベルの住所",
+    "person_affiliation": "個人名＋所属",
+    "person_name": "個人名",
+    "my_number": "マイナンバー",
+    "credit_card": "クレジットカード番号",
+    "bank_account": "銀行口座番号",
+}
+
+PLACEHOLDERS = {
+    "email": "<EMAIL>",
+    "phone": "<PHONE>",
+    "address": "<ADDRESS>",
+    "person_affiliation": "<PERSON_AFFILIATION>",
+    "person_name": "<PERSON_NAME>",
+    "my_number": "<MY_NUMBER>",
+    "credit_card": "<CREDIT_CARD>",
+    "bank_account": "<BANK_ACCOUNT>",
+}
+
+TARGET_PII_TYPES = tuple(PII_LABELS_JA)
+
+
+@dataclass(frozen=True)
+class PIIMatch:
+    """検出されたPIIの位置と監査用メタデータ。位置はNFKC後の文字列基準。"""
+
+    pii_type: str
+    field: str
+    start: int
+    end: int
+    value: str
+    method: str
+    confidence: str = "high"
+
+    @property
+    def label_ja(self) -> str:
+        return PII_LABELS_JA.get(self.pii_type, self.pii_type)
+
+    @property
+    def masked_value(self) -> str:
+        return mask_value(self.pii_type, self.value)
+
+    @property
+    def placeholder(self) -> str:
+        return PLACEHOLDERS.get(self.pii_type, "<PII>")
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "pii_type": self.pii_type,
+            "pii_type_ja": self.label_ja,
+            "field": self.field,
+            "start": self.start,
+            "end": self.end,
+            "matched_value_masked": self.masked_value,
+            "method": self.method,
+            "confidence": self.confidence,
+            "placeholder": self.placeholder,
+        }
+
+
+def normalize_text(value: Any) -> str:
+    """全角・半角差を吸収して照合する。"""
+
+    if value is None:
+        return ""
+    return unicodedata.normalize("NFKC", str(value))
+
+
+def mask_value(pii_type: str, value: str) -> str:
+    """監査JSONにPIIそのものを再掲しないためのマスキング。"""
+
+    if not value:
+        return ""
+    if pii_type == "email" and "@" in value:
+        local, domain = value.split("@", 1)
+        masked_local = local[0] + "*" * max(1, len(local) - 2) + local[-1:]
+        return f"{masked_local}@{domain}"
+    if pii_type in {"phone", "my_number", "credit_card", "bank_account"}:
+        chars = list(value)
+        positions = [i for i, char in enumerate(chars) if char.isalnum()]
+        keep = 4
+        for index in positions[:-keep]:
+            chars[index] = "*"
+        return "".join(chars)
+    if pii_type == "address":
+        return value[:3] + "***"
+    if pii_type == "person_affiliation":
+        return "***"
+    return "***"
+
+
+def is_valid_luhn(value: str) -> bool:
+    digits = [int(char) for char in value if char.isdigit()]
+    if len(digits) < 13 or len(digits) > 19:
+        return False
+    checksum = 0
+    parity = len(digits) % 2
+    for index, digit in enumerate(digits):
+        if index % 2 == parity:
+            digit *= 2
+            if digit > 9:
+                digit -= 9
+        checksum += digit
+    return checksum % 10 == 0
+
+
+def is_valid_mynumber(value: str) -> bool:
+    """12桁の個人番号のチェックデジットを検証する。"""
+
+    digits = [int(char) for char in value if char.isdigit()]
+    if len(digits) != 12:
+        return False
+    # 左から11桁に対して、右から 2,3,4,5,6,7 を繰り返す。
+    weights = [2, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6]
+    total = sum(digit * weight for digit, weight in zip(reversed(digits[:11]), weights))
+    check_digit = (11 - (total % 11)) % 10
+    return check_digit == digits[-1]
+
+
+EMAIL_RE = re.compile(
+    r"(?<![A-Za-z0-9._%+\-])([A-Za-z0-9.!#$%&'*+/=?^_`{|}~-]+@[A-Za-z0-9-]+(?:\.[A-Za-z0-9-]+)+)(?![A-Za-z0-9._%+\-])"
+)
+PHONE_SEPARATED_RE = re.compile(
+    # 改行を区切りに含めない。住所末尾の番地と次行の電話番号を
+    # ひとつの不正な候補として連結しないため、空白は半角スペース・タブのみ。
+    # 先行する郵便番号・日付などが不正候補になっても、後続の電話番号の
+    # 開始位置を検査できるよう、候補全体を先読みして重複開始を許可する。
+    r"(?<!\d)(?=(?P<value>(?:\+81[ \t-]?)?0?\d{1,4}(?:[ \t]?-[ \t]?|[ \t])\d{1,4}(?:[ \t]?-[ \t]?|[ \t])\d{3,4})(?!\d))"
+)
+PHONE_MOBILE_RE = re.compile(r"(?<!\d)0[789]0\d{8}(?!\d)")
+PHONE_PLAIN_RE = re.compile(
+    r"(?<!\d)(?:0120\d{6}|0570\d{6}|050\d{8}|0[1-9]\d{8})(?!\d)"
+)
+PHONE_CONTEXT_RE = re.compile(
+    # ラベル候補も先読みして、TELの後に別のFAXが続く場合などの
+    # 後続ラベルを取りこぼさない。
+    r"(?=(?:電話|携帯|連絡先|tel|telephone|phone|fax|ファクシミリ|ファックス)\s*[:：]?[^0-9+]{0,10}(?P<value>\+?\d[\d\s().-]{8,18}\d))",
+    re.IGNORECASE,
+)
+# 12桁（4-4-4区切りも可）。チェックデジットに加えて、ラベル文脈を必須にする。
+# 無作為な12桁の1割はチェックデジットを通るため、URL中のIDや注文番号を誤検出しないため。
+MY_NUMBER_RE = re.compile(r"(?<![\d-])(?:\d{4}[ -]?\d{4}[ -]?\d{4})(?![\d-])")
+MY_NUMBER_CONTEXT_RE = re.compile(r"(?:個人番号|マイナンバー|my\s*number)", re.IGNORECASE)
+# 13〜19桁。区切り書式（4-4-4-4、4-6-5 等）かラベル文脈を必須にする（Luhn だけでは1割が通る）。
+CARD_RE = re.compile(r"(?<![\d-])(?:\d{4}[ -]\d{4}[ -]\d{4}[ -]\d{1,7}|\d{4}[ -]\d{6}[ -]\d{5}|\d{13,19})(?![\d-])")
+CARD_CONTEXT_RE = re.compile(
+    r"(?:カード番号|クレジットカード|クレカ|card\s*(?:no\.?|number)|credit\s*card|visa|master\s*card|jcb|amex|american\s*express|diners)",
+    re.IGNORECASE,
+)
+# 直前にこれらのラベルがある数字列は注文・伝票等の番号とみなして除外する。
+NUMBER_NEGATIVE_CONTEXT_RE = re.compile(
+    r"(?:注文番号|受注番号|伝票番号|追跡番号|お問い?合わせ番号|受付番号|管理番号|会員番号|予約番号|商品番号|型番|isbn|jan|tracking|order\s*(?:no\.?|number))",
+    re.IGNORECASE,
+)
+
+# 都道府県・市区町村に続く番地（1-2-3、1丁目2番3号等）を必須にする。番地の後ろの
+# 建物名・部屋番号も住所の一部として取り込む（「<ADDRESS>-802」のような取り残しを防ぐ）。
+# 番地: 算用数字と漢数字の両方、「1-2-3」「1丁目2番3号」「一丁目二番三号」「1丁目2-3」「1ー2ー3」を許容
+_NUM = r"[0-9一二三四五六七八九十〇零]+"
+# 区切り記号（-、－、‐、ー）の前後には OCR・Web抽出由来の空白を1つまで許す。
+_SEP = r"\s?[-－‐ー]\s?"
+_ADDRESS_BLOCK = (
+    rf"(?:{_NUM}\s?丁目\s?{_NUM}(?:\s?番(?:地)?\s?(?:{_NUM}\s?号?)?|{_SEP}{_NUM}(?:{_SEP}{_NUM})?)"
+    rf"|{_NUM}(?:{_SEP}{_NUM}){{1,3}}(?:番地?)?"
+    rf"|{_NUM}\s?番地?(?:\s?{_NUM}\s?号)?)"
+)
+_ADDRESS_TAIL = (
+    r"(?:\s*[^\s,、。\n()（）]{0,20}?(?:ビル|マンション|ハイツ|コーポ|レジデンス|アパート|タワー|ハウス|荘|寮|号館)[^\s,、。\n()（）]{0,10})?"
+    r"(?:\s*\d{1,4}\s*(?:号室|号|[Ff]|階))?"
+)
+# 都道府県から始まる住所。改行・空白の混入（Web抽出やOCR）を許すため、区切りは句読点のみとする。
+ADDRESS_RE = re.compile(
+    r"(?P<value>(?:北海道|東京都|大阪府|京都府|[一-龥々]{2,3}県)[^,、。]{1,60}?(?:市|区|町|村)[^,、。]{0,35}?" + _ADDRESS_BLOCK + _ADDRESS_TAIL + r")"
+)
+# 都道府県が省かれた「福岡市博多区博多駅前1-2-3」「宇都宮市江野町1-15」。市・区の後に町名相当を1文字以上要求する。
+ADDRESS_CITY_RE = re.compile(
+    r"(?P<value>(?<![都京大])[一-龥々ぁ-ゖ]{1,6}(?:市|区|郡)[一-龥々ぁ-ゖァ-ヶー0-9\s]{1,30}?(?:町|村|区|丁目|[一-龥々]{1,6})" + _ADDRESS_BLOCK + _ADDRESS_TAIL + r")"
+)
+# ラベル付きの住所は、都道府県が省かれた「宇都宮市江野町1-15」の形も許可する（残存確認で発見した取りこぼし）。
+ADDRESS_CONTEXT_RE = re.compile(
+    r"(?:住所|所在地|送付先|配送先)\s*[:：]?\s*(?P<value>(?:北海道|東京都|大阪府|京都府|[一-龥々]{2,3}県|[一-龥々ぁ-ゖァ-ヶー]{1,6}(?:市|区|郡))[^。,、]{1,80}?" + _ADDRESS_BLOCK + _ADDRESS_TAIL + r")"
+)
+
+# 氏名: 漢字2〜6字、または漢字1〜3字＋かな2〜6字（佐藤ゆかり）。「皆さん」のような1字＋さんは拾わない。
+_NAME = r"(?:[一-龥々]{2,6}|[一-龥々]{1,3}\s?[ぁ-ゖァ-ヶー]{2,6})"
+# 所属: 法人格で始まる名称、または組��を示す語尾で終わる名称（20字以内）。任意で部署。
+_ORG_PREFIX = r"(?:株式会社|有限会社|合同会社|合資会社|一般社団法人|一般財団法人|公益社団法人|公益財団法人|[Nn][Pp][Oo]法人|学校法人|医療法人|社会福祉法人|独立行政法人|国立研究開発法人)"
+_ORG_SUFFIX = r"(?:株式会社|有限会社|合同会社|会社|大学院|大学|高等学校|高校|中学校|小学校|専門学校|病院|クリニック|医院|省|庁|県庁|市役所|区役所|町役場|村役場|銀行|信用金庫|研究所|研究センター|協会|連盟|組合|法律事務所|事務所|事務局|財団|法人|商工会議所|観光局|放送局|新聞社|出版社)"
+_ORG = rf"(?:{_ORG_PREFIX}[^\s。、,，()（）]{{1,20}}|[^\s。、,，()（）のがはをにでと]{{1,20}}?{_ORG_SUFFIX})"
+_ORG_RE = re.compile(_ORG)
+_DEPT = r"(?:\s*[^\s。、,，()（）]{0,15}?(?:部|課|室|科|係|チーム|支店|支社|営業所|研究室))?"
+# 所属の後ろに続く役職（「株式会社ABC 代表」「○○会 会員」）も置換範囲に含める。
+_TITLE_OPT = r"(?:\s*[^\s。、,，()（）の]{0,8}?(?:長|社長|部長|課長|主任|教授|准教授|講師|代表|取締役|[Cc][Ee][Oo]|[Cc][Tt][Oo]|マネージャー|リーダー|担当|研究員|弁護士|職員|会員|理事|社員|員))?"
+_TITLE = r"(?:[^\s。、,，()（）の]{0,8}?(?:長|社長|部長|課長|主任|教授|准教授|講師|代表|取締役|[Cc][Ee][Oo]|[Cc][Tt][Oo]|マネージャー|リーダー|担当|研究員|弁護士))"
+# 「氏名：山田太郎（株式会社ABC）」「担当者：山田太郎、株式会社ABC 営業部」
+NAME_AFFILIATION_LABEL_RE = re.compile(
+    r"(?:氏名|お名前|担当者|代表者|名義人?)\s*[:：]\s*"
+    rf"(?P<value>(?P<name>{_NAME})\s*(?:[（(、,]|所属\s*[:：])\s*(?P<affiliation>{_ORG}{_DEPT}{_TITLE_OPT})[）)]?)"
+)
+# 「山田太郎さん、株式会社ABC」「山田太郎氏（株式会社ABC 営業部）」
+NAME_AFFILIATION_SUFFIX_RE = re.compile(
+    rf"(?P<value>(?P<name>{_NAME})(?:さん|氏|様|先生)[、,\s（(]+(?P<affiliation>{_ORG}{_DEPT}{_TITLE_OPT})[）)]?)"
+)
+# 「株式会社ABC 営業部 部長 山田太郎さん」「○○大学教授・山田太郎氏」（所属→役職→氏名の順）。
+# 役職か「・」区切りのどちらかと、敬称を必須にする。「会社の同僚さん」のような役割語を氏名にしないため。
+AFFILIATION_NAME_RE = re.compile(
+    rf"(?P<value>(?P<affiliation>{_ORG}{_DEPT})\s*(?:(?:の)?\s*{_TITLE}\s*(?:・|の|\s)?|・)\s*(?P<name>{_NAME})(?:さん|氏|様|先生))"
+)
+# 個人名だけ（ラベル文脈）。かな名も許可し、フォームの定型語は除外する。
+_NAME_TOKEN = r"[一-龥々ぁ-ゖァ-ヶー]{1,8}"
+NAME_CONTEXT_RE = re.compile(
+    r"(?:氏名|お名前|名前|担当者|代表者|名義人?)\s*[:：]\s*"
+    rf"(?P<value>{_NAME_TOKEN}(?:\s*{_NAME_TOKEN})?)"
+)
+NAME_STOPWORDS = {"必須", "任意", "未定", "なし", "不明", "非公開", "匿名", "ニックネーム", "ハンドルネーム", "例", "未入力", "空欄", "入力"}
+# 欧文氏名は署名（by / Author / 執筆者）か敬称（Mr. / Dr.）の文脈に限る。単独の「John Smith」は地名・商品名と区別できないため対象外。
+LATIN_NAME_RE = re.compile(
+    r"(?:(?i:\bby|\bauthor|\bwritten by|\bphoto by|\btext by|\bposted by)|執筆者|著者|文責|撮影|取材|記者|翻訳|監修)\s*[:：]?\s*"
+    r"(?P<value>(?:(?:Mr|Ms|Mrs|Dr|Prof)\.?\s+)?[A-Z][a-z]+(?:\s[A-Z]\.?)?\s[A-Z][a-z]+(?:\s[A-Z][a-z]+)?)"
+    r"|(?P<value2>(?:Mr|Ms|Mrs|Dr|Prof)\.\s+[A-Z][a-z]+(?:\s[A-Z][a-z]+)?)"
+)
+BANK_CONTEXT_RE = re.compile(
+    r"(?:口座番号|口座|振込先|銀行口座)\D{0,20}(?P<value>\d{7})(?!\d)"
+)
+# URL では数字列がIDであることが多く、番号系の検出は行わない（メール・電話のみ）。
+URL_EXCLUDED_TYPES = frozenset({"my_number", "credit_card", "bank_account"})
+
+
+def _has_context(text: str, position: int, pattern: re.Pattern[str], window: int) -> bool:
+    """position の直前 window 文字以内に pattern があるか。"""
+
+    return pattern.search(text, max(0, position - window), position) is not None
+
+
+# --- 形態素解析による人名検出 -------------------------------------------------
+# SudachiPy（Apache-2.0）の辞書は姓・名を「名詞,固有名詞,人名,姓／名」として持つ。
+# 姓＋名の連続、または敬称・役割ラベル付きの単独人名を候補にし、所属・役職の文脈が
+# 近くにあれば「個人名＋所属」、敬称・役割ラベルがあれば「個人名」として置換する。
+# 文脈のない裸の姓名（「尾田栄一郎はどんな人」）は既定では置換せず、件数だけ数える。
+HONORIFIC_AFTER_RE = re.compile(r"(?:さん|氏|様|先生|くん|君|ちゃん|さま)")
+# 役割ラベル。1文字の語（文・絵・訳・作・画）は「名作」「原作」を拾わないよう、区切り文字か行頭の直後に限る。
+# 出演・司会は俳優・司会者（公人）を指すため含めない。
+ROLE_LABEL_BEFORE_RE = re.compile(
+    r"(?:(?:執筆者|執筆|著者|文責|記者|編集者|担当者?|講師|監修|取材|撮影|翻訳|写真|(?i:by))|(?:^|[\s、,:：・/｜|(（【\[])(?:文|絵|訳|作|画))\s*[:：=]?\s*$",
+)
+TITLE_CONTEXT_RE = re.compile(
+    r"(?:代表取締役|取締役|社長|副社長|会長|副会長|理事長|理事|専務|常務|執行役員|部長|次長|課長|係長|主任|所長|院長|校長|園長|館長|局長|"
+    r"教授|准教授|助教|講師|研究員|主席|主幹|(?i:ceo|cto|coo|cfo)|マネージャー|ディレクター|プロデューサー|エンジニア|デザイナー|コンサルタント|"
+    r"アナリスト|弁護士|税理士|会計士|司法書士|行政書士|社労士|医師|看護師|薬剤師|"
+    r"代表|担当|職員|社員|スタッフ|広報|主宰|オーナー|店長|支配人|学長|総長|会員|委員長|委員)"
+    # 監督・選手・議員・市長・知事・大臣など公人を示す役職は含めない（公人名は学習データとして保持する）。
+)
+NAME_CONTEXT_WINDOW = 25
+_SENTENCE_BREAK_RE = re.compile(r"[。！？!?\n]")
+
+
+def _same_sentence_window(text: str, start: int, end: int, window: int) -> tuple[str, str]:
+    """氏名の前後 window 文字のうち、同じ文（句点・改行で区切られない範囲）だけを返す。"""
+
+    before = text[max(0, start - window):start]
+    after = text[end:end + window]
+    breaks = list(_SENTENCE_BREAK_RE.finditer(before))
+    if breaks:
+        before = before[breaks[-1].end():]
+    cut = _SENTENCE_BREAK_RE.search(after)
+    if cut:
+        after = after[:cut.start()]
+    return before, after
+
+
+class SudachiNameFinder:
+    """本文から人名の範囲（姓＋名の連続、または単独の姓・名）を返す。"""
+
+    CHUNK_CHARS = 8000  # Sudachi の入力上限（49,149バイト）に収める
+
+    def __init__(self) -> None:
+        from sudachipy import Dictionary, SplitMode
+
+        self._tokenizer = Dictionary(dict="core").create()
+        self._mode = SplitMode.A
+
+    def _chunks(self, text: str):
+        start = 0
+        while start < len(text):
+            end = min(len(text), start + self.CHUNK_CHARS)
+            if end < len(text):
+                newline = text.rfind("\n", start + self.CHUNK_CHARS // 2, end)
+                if newline > 0:
+                    end = newline + 1
+            yield start, text[start:end]
+            start = end
+
+    def find(self, text: str) -> list[tuple[int, int, str]]:
+        """(start, end, kind) を返す。kind は ``pair``（姓＋名）か ``single``。"""
+
+        spans: list[tuple[int, int, str]] = []
+        for offset, piece in self._chunks(text):
+            run: list[tuple[int, int, str]] = []  # (start, end, 姓/名/一般)
+
+            def flush() -> None:
+                if not run:
+                    return
+                kinds = [kind for _, _, kind in run]
+                start, end = run[0][0], run[-1][1]
+                if "姓" in kinds and "名" in kinds and kinds.index("姓") < len(kinds) - 1:
+                    spans.append((start, end, "pair"))
+                elif len(run) >= 2 and end - start >= 3:
+                    spans.append((start, end, "pair"))
+                elif end - start >= 2:
+                    spans.append((start, end, "single"))
+                run.clear()
+
+            pending_connector = False
+            for morpheme in self._tokenizer.tokenize(piece, self._mode):
+                pos = morpheme.part_of_speech()
+                surface = morpheme.surface()
+                if pos[2] == "人名":
+                    run.append((offset + morpheme.begin(), offset + morpheme.end(), pos[3]))
+                    pending_connector = False
+                elif run and not pending_connector and (pos[0] == "空白" or surface in ("・", "･", "=", "＝")):
+                    # 「山田 太郎」「ジョン・スミス」の空白・中黒は1つだけ連結として扱う
+                    pending_connector = True
+                else:
+                    flush()
+                    pending_connector = False
+            flush()
+        return spans
+
+
+def _digits(value: str) -> str:
+    return "".join(char for char in value if char.isdigit())
+
+
+def _valid_phone(value: str) -> bool:
+    digits = _digits(value)
+    if value.startswith("+81"):
+        digits = "0" + digits[2:]
+    if len(digits) not in {10, 11} or not digits.startswith("0"):
+        return False
+    if digits.startswith(("070", "080", "090")):
+        return len(digits) == 11
+    return digits[1] in "123456789" and len(digits) in {10, 11}
+
+
+def _overlap(first: PIIMatch, second: PIIMatch) -> bool:
+    return first.start < second.end and second.start < first.end
+
+
+def _select_non_overlapping(matches: Iterable[PIIMatch]) -> list[PIIMatch]:
+    """重なった候補は、長く信頼度の���い候補を優先して1回だけ置換する。"""
+
+    confidence_rank = {"high": 2, "medium": 1, "low": 0}
+    ordered = sorted(
+        matches,
+        key=lambda item: (
+            item.start,
+            -(item.end - item.start),
+            -confidence_rank.get(item.confidence, 0),
+        ),
+    )
+    selected: list[PIIMatch] = []
+    for candidate in ordered:
+        if any(_overlap(candidate, existing) for existing in selected):
+            continue
+        selected.append(candidate)
+    return sorted(selected, key=lambda item: (item.start, item.end, item.pii_type))
+
+
+class PIIDetector:
+    """URLと本文から指定7種類だけを検出し、プレースホルダーへ置換する。"""
+
+    def __init__(
+        self,
+        include_url: bool = True,
+        use_sudachi: bool = True,
+        mask_honorific_names: bool = False,
+        mask_bare_names: bool = False,
+        name_context_window: int = NAME_CONTEXT_WINDOW,
+        affiliation_titles: bool = True,
+    ) -> None:
+        self.include_url = include_url
+        self.use_sudachi = use_sudachi
+        self.name_context_window = name_context_window
+        # 既定では組織名（法人格・組織語尾）と役職語（代表取締役、教授等）の両方を所属文脈とする。
+        # 組織名だけに狭める場合は affiliation_titles=False（CLI: --no-affiliation-titles）。
+        self.affiliation_titles = affiliation_titles
+        self.mask_honorific_names = mask_honorific_names
+        self.mask_bare_names = mask_bare_names
+        self._names: SudachiNameFinder | None = None
+        # 置換しなかった姓名の件数（方針判断用）。敬称のみ／文脈なし。
+        self.honorific_name_candidates = 0
+        self.honorific_name_records = 0
+        self.bare_name_candidates = 0
+        self.bare_name_records = 0
+
+    def _name_finder(self) -> SudachiNameFinder:
+        if self._names is None:
+            self._names = SudachiNameFinder()
+        return self._names
+
+    def _detect_names(self, normalized: str, field: str) -> list[PIIMatch]:
+        matches: list[PIIMatch] = []
+        bare = 0
+        honorific_only = 0
+        for start, end, kind in self._name_finder().find(normalized):
+            value = normalized[start:end]
+            before, after = _same_sentence_window(normalized, start, end, self.name_context_window)
+            honorific = HONORIFIC_AFTER_RE.match(normalized, end) is not None
+            role = ROLE_LABEL_BEFORE_RE.search(normalized[max(0, start - 16):start]) is not None
+            affiliated = bool(_ORG_RE.search(before) or _ORG_RE.search(after))
+            if not affiliated and self.affiliation_titles:
+                affiliated = bool(TITLE_CONTEXT_RE.search(before) or TITLE_CONTEXT_RE.search(after))
+            if affiliated and (kind == "pair" or honorific or role):
+                matches.append(PIIMatch("person_affiliation", field, start, end, value, "sudachi_name_affiliation", "medium"))
+            elif role:
+                matches.append(PIIMatch("person_name", field, start, end, value, "sudachi_name_role", "medium"))
+            elif honorific:
+                # 「○○さん」だけでは私人か公人（俳優、作家、選手）か区別できないため、既定では置換しない。
+                if self.mask_honorific_names:
+                    matches.append(PIIMatch("person_name", field, start, end, value, "sudachi_name_honorific", "low"))
+                else:
+                    honorific_only += 1
+            elif kind == "pair":
+                if self.mask_bare_names:
+                    matches.append(PIIMatch("person_name", field, start, end, value, "sudachi_name_bare", "low"))
+                else:
+                    bare += 1
+        if honorific_only:
+            self.honorific_name_candidates += honorific_only
+            self.honorific_name_records += 1
+        if bare:
+            self.bare_name_candidates += bare
+            self.bare_name_records += 1
+        return matches
+
+    @staticmethod
+    def _looks_like_phone(value: str) -> bool:
+        """住所候補の末尾が電話番号（区切り付き10桁以上）なら住所とみなさない。"""
+
+        tail = re.search(r"(\d+(?:\s?[-－‐ー]\s?\d+)+)\s*$", value)
+        if not tail:
+            return False
+        digits = _digits(tail.group(1))
+        return len(digits) >= 9 and "丁目" not in value[-20:] and "番" not in value[-20:]
+
+    def detect(self, text: Any, field: str = "content") -> list[PIIMatch]:
+        normalized = normalize_text(text)
+        if not normalized:
+            return []
+        matches: list[PIIMatch] = []
+
+        def add(
+            pattern: re.Pattern[str],
+            pii_type: str,
+            method: str,
+            confidence: str = "high",
+            group: str | None = None,
+        ) -> None:
+            for found in pattern.finditer(normalized):
+                value = found.group(group) if group else found.group(0)
+                start = found.start(group) if group else found.start()
+                end = found.end(group) if group else found.end()
+                matches.append(PIIMatch(pii_type, field, start, end, value, method, confidence))
+
+        add(EMAIL_RE, "email", "regex_email")
+        for found in PHONE_SEPARATED_RE.finditer(normalized):
+            value = found.group("value")
+            if _valid_phone(value):
+                matches.append(PIIMatch("phone", field, found.start("value"), found.end("value"), value, "regex_phone"))
+        for found in PHONE_MOBILE_RE.finditer(normalized):
+            if _valid_phone(found.group(0)):
+                matches.append(PIIMatch("phone", field, found.start(), found.end(), found.group(0), "regex_phone"))
+        for found in PHONE_PLAIN_RE.finditer(normalized):
+            if _valid_phone(found.group(0)):
+                matches.append(PIIMatch("phone", field, found.start(), found.end(), found.group(0), "regex_phone"))
+        for found in PHONE_CONTEXT_RE.finditer(normalized):
+            value = found.group("value")
+            if _valid_phone(value):
+                matches.append(PIIMatch("phone", field, found.start("value"), found.end("value"), value, "context_phone", "medium"))
+
+        if field != "url":
+            for found in MY_NUMBER_RE.finditer(normalized):
+                value = found.group(0)
+                if not is_valid_mynumber(value):
+                    continue
+                if _has_context(normalized, found.start(), NUMBER_NEGATIVE_CONTEXT_RE, 20):
+                    continue
+                # 区切り書式だけでは数表・型番を誤検出するため、マイナンバーはラベル文脈を必須にする。
+                if _has_context(normalized, found.start(), MY_NUMBER_CONTEXT_RE, 40):
+                    matches.append(PIIMatch("my_number", field, found.start(), found.end(), value, "checksum_mynumber"))
+            for found in CARD_RE.finditer(normalized):
+                value = found.group(0)
+                if not is_valid_luhn(value) or len(_digits(value)) == 12:
+                    continue
+                if _has_context(normalized, found.start(), NUMBER_NEGATIVE_CONTEXT_RE, 20):
+                    continue
+                labeled = _has_context(normalized, found.start(), CARD_CONTEXT_RE, 40)
+                grouped = not value.isdigit()
+                if labeled or grouped:
+                    matches.append(PIIMatch("credit_card", field, found.start(), found.end(), value, "checksum_luhn", "high" if labeled else "medium"))
+
+        patterns = [
+            (ADDRESS_RE, "address", "regex_address"),
+            (ADDRESS_CITY_RE, "address", "regex_address_city"),
+            (ADDRESS_CONTEXT_RE, "address", "context_address"),
+            (NAME_AFFILIATION_LABEL_RE, "person_affiliation", "context_name_affiliation"),
+            (NAME_AFFILIATION_SUFFIX_RE, "person_affiliation", "context_name_affiliation"),
+            (AFFILIATION_NAME_RE, "person_affiliation", "context_affiliation_name"),
+        ]
+        if field != "url":
+            patterns.append((BANK_CONTEXT_RE, "bank_account", "context_bank_account"))
+        for pattern, pii_type, method in patterns:
+            add(pattern, pii_type, method, "medium", "value")
+        matches = [m for m in matches if not (m.pii_type == "address" and self._looks_like_phone(m.value))]
+        if self.use_sudachi and field != "url":
+            matches.extend(self._detect_names(normalized, field))
+        for found in LATIN_NAME_RE.finditer(normalized):
+            group = "value" if found.group("value") else "value2"
+            matches.append(PIIMatch("person_name", field, found.start(group), found.end(group), found.group(group), "context_latin_name", "medium"))
+        for found in NAME_CONTEXT_RE.finditer(normalized):
+            value = found.group("value")
+            if value in NAME_STOPWORDS or value.split()[0] in NAME_STOPWORDS:
+                continue
+            matches.append(PIIMatch("person_name", field, found.start("value"), found.end("value"), value, "context_name", "medium"))
+
+        # 同一type・同一位置の重複を除き、出現順に返す。重複範囲は検出結果として
+        # 残すが、置換時には _select_non_overlapping で一つにまとめる。
+        unique: dict[tuple[str, str, int, int], PIIMatch] = {}
+        for match in matches:
+            unique[(match.pii_type, match.field, match.start, match.end)] = match
+        return sorted(unique.values(), key=lambda item: (item.start, item.end, item.pii_type))
+
+    def detect_record(self, url: Any, content: Any) -> list[PIIMatch]:
+        matches: list[PIIMatch] = []
+        if self.include_url:
+            matches.extend(self.detect(url, "url"))
+        matches.extend(self.detect(content, "content"))
+        return matches
+
+    def replace_text(self, text: Any, field: str = "content") -> tuple[str, list[PIIMatch]]:
+        """PIIをプレースホルダーに置換し、実際に置換した候補を返す���
+
+        NFKC正規化後の文字列を返すため、全角のメールアドレス等も一貫した
+        表記になる。検出位置は返却文字列（置換前のNFKC文字列）に対応する。
+        """
+
+        normalized = normalize_text(text)
+        if not normalized:
+            return normalized, []
+        selected = _select_non_overlapping(self.detect(normalized, field))
+        replaced = normalized
+        for match in reversed(selected):
+            replaced = replaced[: match.start] + match.placeholder + replaced[match.end :]
+        return replaced, selected
+
+    def replace_record(self, url: Any, content: Any) -> tuple[str, str, list[PIIMatch]]:
+        replaced_url, url_matches = (self.replace_text(url, "url") if self.include_url else (normalize_text(url), []))
+        replaced_content, content_matches = self.replace_text(content, "content")
+        return replaced_url, replaced_content, url_matches + content_matches
+
+
+def matches_to_dict(matches: Iterable[PIIMatch]) -> list[dict[str, Any]]:
+    return [match.to_dict() for match in matches]

code/e5cb5ca/src/pii_residual_check.py

@@ -0,0 +1,195 @@
+"""置換後データの PII 残存を、独立した検出器（GLiNER-ja）で確認する（監査項目12）。
+
+``pii_detector.py`` と同じ検出器で再走査しても残存は必ず 0 になるため、
+学習済み日本語 PII NER ``DataSign/gliner-ja-pii-v1``（Apache-2.0）で
+サンプルを走査し、プレースホルダー以外に残っている氏名・電話・住所・
+メール・口座番号を数える。``--original`` に置換前の parquet を渡すと、
+同じ文書で GLiNER が置換前に検出した実体のうち置換後に消えている割合
+（決定的検出器の再現率の目安）も出す。
+
+    uv sync --group pii-check
+    uv run python abeja-cc-ja/src/pii_residual_check.py --input <replaced.parquet> --sample 500 --output pii_residual.json
+
+モデルは最大160トークンのため、文書を文字数で分割して重なり付きで走査する。
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import random
+import time
+import unicodedata
+from collections import Counter, defaultdict
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+import pyarrow.parquet as pq
+
+from pii_detector import NAME_CONTEXT_WINDOW, TITLE_CONTEXT_RE, _ORG_RE, _same_sentence_window
+
+
+MODEL_NAME = "DataSign/gliner-ja-pii-v1"
+LABELS = ["person name", "phone number", "address", "email address", "account number"]
+LABEL_TO_TYPE = {
+    "person name": "person_name",
+    "phone number": "phone",
+    "address": "address",
+    "email address": "email",
+    "account number": "bank_account",
+}
+PLACEHOLDER_MARKERS = ("<EMAIL>", "<PHONE>", "<ADDRESS>", "<PERSON_NAME>", "<PERSON_AFFILIATION>", "<MY_NUMBER>", "<CREDIT_CARD>", "<BANK_ACCOUNT>")
+
+
+def load_model(device: str | None):
+    from gliner import GLiNER
+    from gliner.data_processing import WordsSplitter
+
+    class JapaneseSplitterNoWS:
+        def __init__(self) -> None:
+            self._base = WordsSplitter(splitter_type="janome")
+
+        def __call__(self, text: str):
+            for token, start, end in self._base(text):
+                if token.strip() == "":
+                    continue
+                yield token, start, end
+
+    model = GLiNER.from_pretrained(MODEL_NAME, max_width=25)
+    model.data_processor.words_splitter = JapaneseSplitterNoWS()
+    if device:
+        try:
+            model = model.to(device)
+        except Exception:  # noqa: BLE001 - デバイス非対応時はCPUのまま
+            pass
+    model.eval()
+    return model
+
+
+def chunks(text: str, size: int, overlap: int):
+    start = 0
+    while start < len(text):
+        end = min(len(text), start + size)
+        yield start, text[start:end]
+        if end == len(text):
+            break
+        start = end - overlap
+
+
+def predict(model, text: str, threshold: float, chunk_chars: int, overlap: int) -> list[dict[str, Any]]:
+    found: dict[tuple[str, int, int], dict[str, Any]] = {}
+    for offset, piece in chunks(text, chunk_chars, overlap):
+        for entity in model.predict_entities(piece, LABELS, threshold=threshold):
+            key = (entity["label"], offset + entity["start"], offset + entity["end"])
+            if key not in found:
+                found[key] = {"label": entity["label"], "start": key[1], "end": key[2], "text": entity["text"], "score": round(float(entity["score"]), 3)}
+    return sorted(found.values(), key=lambda item: (item["start"], item["end"]))
+
+
+def is_placeholder(text: str) -> bool:
+    return any(marker in text for marker in PLACEHOLDER_MARKERS) or "<" in text
+
+
+def mask(text: str) -> str:
+    return text[:1] + "*" * max(1, len(text) - 1)
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--input", type=Path, required=True, help="置換後の parquet（url, content）")
+    parser.add_argument("--original", type=Path, default=None, help="置換前の parquet（同じ行順）。再現率の目安を出す")
+    parser.add_argument("--sample", type=int, default=500)
+    parser.add_argument("--seed", type=int, default=20260904)
+    parser.add_argument("--threshold", type=float, default=0.5)
+    parser.add_argument("--chunk-chars", type=int, default=200)
+    parser.add_argument("--overlap", type=int, default=40)
+    parser.add_argument("--max-chars", type=int, default=3000, help="1文書あたり走査する最大文字数")
+    parser.add_argument("--device", default=None, help="cpu / mps / cuda（既定はGLiNERの既定）")
+    parser.add_argument("--output", type=Path, required=True)
+    args = parser.parse_args(argv)
+
+    table = pq.read_table(args.input, columns=["url", "content"])
+    total = table.num_rows
+    rng = random.Random(args.seed)
+    indices = sorted(rng.sample(range(total), min(args.sample, total)))
+    original = pq.read_table(args.original, columns=["content"]) if args.original else None
+    model = load_model(args.device)
+
+    residual_counts: Counter = Counter()
+    residual_docs: Counter = Counter()
+    examples: dict[str, list[dict[str, Any]]] = defaultdict(list)
+    recall_found: Counter = Counter()
+    recall_removed: Counter = Counter()
+    # 「個人名＋所属」の定義（同一文・前後25文字に所属か役職）に該当する人名だけの再現率
+    ctx_found = 0
+    ctx_removed = 0
+    started = time.perf_counter()
+    docs_with_residual = 0
+    for index in indices:
+        row = table.slice(index, 1).to_pylist()[0]
+        text = unicodedata.normalize("NFKC", row.get("content") or "")[: args.max_chars]
+        entities = [e for e in predict(model, text, args.threshold, args.chunk_chars, args.overlap) if not is_placeholder(e["text"])]
+        if entities:
+            docs_with_residual += 1
+        seen_types = set()
+        for entity in entities:
+            pii_type = LABEL_TO_TYPE[entity["label"]]
+            residual_counts[pii_type] += 1
+            seen_types.add(pii_type)
+            if len(examples[pii_type]) < 5:
+                context = text[max(0, entity["start"] - 25): entity["start"]] + "[" + mask(entity["text"]) + "]" + text[entity["end"]: entity["end"] + 25]
+                examples[pii_type].append({"record_index": index, "url": row.get("url"), "score": entity["score"], "context_masked": context.replace("\n", " ")})
+        for pii_type in seen_types:
+            residual_docs[pii_type] += 1
+        if original is not None:
+            original_text = unicodedata.normalize("NFKC", original.slice(index, 1).to_pylist()[0].get("content") or "")[: args.max_chars]
+            for entity in predict(model, original_text, args.threshold, args.chunk_chars, args.overlap):
+                pii_type = LABEL_TO_TYPE[entity["label"]]
+                recall_found[pii_type] += 1
+                removed = entity["text"] not in text
+                if removed:
+                    recall_removed[pii_type] += 1
+                if pii_type == "person_name":
+                    before, after = _same_sentence_window(original_text, entity["start"], entity["end"], NAME_CONTEXT_WINDOW)
+                    if _ORG_RE.search(before) or _ORG_RE.search(after) or TITLE_CONTEXT_RE.search(before) or TITLE_CONTEXT_RE.search(after):
+                        ctx_found += 1
+                        ctx_removed += removed
+    elapsed = time.perf_counter() - started
+    result = {
+        "checked_at_utc": datetime.now(timezone.utc).isoformat(),
+        "detector": {"model": MODEL_NAME, "license": "Apache-2.0", "labels": LABELS, "threshold": args.threshold,
+                     "chunk_chars": args.chunk_chars, "overlap": args.overlap, "max_chars": args.max_chars},
+        "input": str(args.input), "total_records": total, "sampled_records": len(indices), "seed": args.seed,
+        "elapsed_s": round(elapsed, 1),
+        "residual": {
+            "records_with_any_residual": docs_with_residual,
+            "records_with_residual_rate": round(docs_with_residual / max(1, len(indices)), 4),
+            "by_type_entities": dict(residual_counts),
+            "by_type_records": dict(residual_docs),
+            "examples_masked": examples,
+        },
+        "note_ja": "GLiNER-ja が置換後テキストで検出した実体（プレースホルダーを除く）。氏名は公人・著者名・作品中の人名も含むため、残存の要否は目視で判断する。",
+    }
+    if original is not None:
+        result["recall_estimate_person_name_with_affiliation_context"] = {
+            "gliner_found_in_original": ctx_found,
+            "removed_after_replacement": ctx_removed,
+            "removed_rate": round(ctx_removed / ctx_found, 3) if ctx_found else None,
+            "note_ja": "GLiNER-ja が検出した人名のうち、同一文・前後25文字に所属か役職がある（＝個人名＋所属の定義に該当する）ものの置換率。",
+        }
+        result["recall_estimate"] = {
+            pii_type: {"gliner_found_in_original": recall_found[pii_type], "removed_after_replacement": recall_removed[pii_type],
+                       "removed_rate": round(recall_removed[pii_type] / recall_found[pii_type], 3) if recall_found[pii_type] else None}
+            for pii_type in sorted(recall_found)
+        }
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    args.output.write_text(json.dumps(result, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+    print(json.dumps({"sampled": len(indices), "records_with_residual": docs_with_residual, "by_type": dict(residual_counts),
+                      "recall_estimate": result.get("recall_estimate"),
+                      "recall_person_name_with_affiliation_context": result.get("recall_estimate_person_name_with_affiliation_context"),
+                      "elapsed_s": round(elapsed, 1)}, ensure_ascii=False))
+
+
+if __name__ == "__main__":
+    main()

code/e5cb5ca/src/review_tally.py

@@ -0,0 +1,53 @@
+"""記入済みの review_samples.csv を集計し、層別の精度・見逃し率を出す。
+
+verdict は ``harmful`` / ``not_harmful`` / ``unsure`` の3値。未記入は未確認として数える。
+出力は ``review_tally.json`` と標準出力の表。
+"""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import json
+from collections import defaultdict
+from datetime import datetime, timezone
+from pathlib import Path
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--csv", type=Path, required=True)
+    parser.add_argument("--output", type=Path, default=None, help="既定は CSV と同じ場所の review_tally.json")
+    args = parser.parse_args(argv)
+    counts: dict[str, dict[str, int]] = defaultdict(lambda: {"harmful": 0, "not_harmful": 0, "unsure": 0, "unreviewed": 0})
+    reviewers: set[str] = set()
+    with args.csv.open(encoding="utf-8", newline="") as handle:
+        for row in csv.DictReader(handle):
+            verdict = (row.get("verdict") or "").strip().lower() or "unreviewed"
+            if verdict not in ("harmful", "not_harmful", "unsure"):
+                verdict = "unreviewed"
+            counts[row["stratum"]][verdict] += 1
+            if row.get("reviewer"):
+                reviewers.add(row["reviewer"])
+    result: dict[str, dict] = {}
+    for stratum, c in sorted(counts.items()):
+        reviewed = c["harmful"] + c["not_harmful"]
+        entry = dict(c)
+        entry["reviewed"] = reviewed
+        if reviewed:
+            if stratum.startswith(("deleted:", "cooccurrence:")):
+                entry["precision"] = round(c["harmful"] / reviewed, 3)  # 削除の妥当性
+            else:
+                entry["harmful_rate"] = round(c["harmful"] / reviewed, 3)  # 保持側の見逃し率
+        result[stratum] = entry
+    output = args.output or args.csv.with_name("review_tally.json")
+    payload = {"tallied_at_utc": datetime.now(timezone.utc).isoformat(), "csv": str(args.csv), "reviewers": sorted(reviewers), "strata": result}
+    output.write_text(json.dumps(payload, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+    print(f"{'stratum':40s} {'harm':>5s} {'not':>5s} {'uns':>5s} {'todo':>5s}  rate")
+    for stratum, e in result.items():
+        rate = e.get("precision", e.get("harmful_rate", ""))
+        print(f"{stratum:40s} {e['harmful']:5d} {e['not_harmful']:5d} {e['unsure']:5d} {e['unreviewed']:5d}  {rate}")
+
+
+if __name__ == "__main__":
+    main()

code/e5cb5ca/src/run_shard.py

@@ -0,0 +1,320 @@
+"""シャード単位のクレンジングパイプライン（本実行用）。
+
+1ファイル（parquet）ごとに次を行う。
+
+1. 有害コンテンツフィルタ（ワードリスト・ドメインブロックリスト・近接共起規則）
+2. 保持分に PII 置換
+3. クリーン済み parquet と監査ファイル（removed.jsonl, audit.jsonl 等）を
+   ``<output-root>/<シャード名>/`` に書き出し、``shard_summary.json`` にまとめる
+4. 任意で HF データセットへバッチアップロード（``--upload-repo``）。アップロード後に
+   ローカルを削除すれば、HF Jobs の一時ディスク（50 GB）でも全シャードを処理できる
+
+``--workers`` でシャード並列に処理する。各ワーカーはワードリスト・ブロックリスト・
+共起規則を1回だけ読み込む（UT1 adult リストで約1.6 GB/ワーカー）。
+``shard_summary.json`` が既にあるシャードと、``--skip-existing-in-repo`` で
+リポジトリに既に出力があるシャードは飛ばすので、途中終了後の再実行ができる。
+
+    uv run python abeja-cc-ja/src/run_shard.py --input-dir <dir> --output-root <out> --workers 7 \\
+        --upload-repo Podtech/abeja-cc-ja-cleaned --upload-prefix outputs/common_crawl_0 --delete-local-after-upload
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import multiprocessing as mp
+import os
+import shutil
+import time
+import traceback
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+import pyarrow.parquet as pq
+
+
+PIPELINE_VERSION = "abeja-cc-ja-cleansing/2026-09-04"
+MODE = "distinct_terms_3plus"
+
+_WORKER: dict[str, Any] = {}
+
+
+def _init_worker(config: dict[str, Any]) -> None:
+    """ワーカー起動時にリソースを1回だけ読み込む。"""
+
+    import sys
+
+    sys.path.insert(0, str(Path(__file__).resolve().parent))
+    from cooccurrence import CooccurrenceDetector, load_rules
+    from domain_blocklist import DomainBlocklist
+
+    _WORKER["config"] = config
+    _WORKER["blocklist"] = None if config["no_blocklist"] else DomainBlocklist.load(Path(config["blocklist_dir"]), Path(config["blocklist_cache_dir"]))
+    _WORKER["cooccurrence"] = None if config["no_cooccurrence"] else CooccurrenceDetector(load_rules(Path(config["cooccurrence_rules"])))
+
+
+def process_shard(input_path: Path, output_root: Path, config: dict[str, Any]) -> dict[str, Any]:
+    """1シャードを処理し、shard_summary を返す（ワーカー内で実行）。"""
+
+    from filter_pii import run_filter as run_pii
+    from filter_toxic import run_toxic_filters
+
+    if not _WORKER:
+        _init_worker(config)
+    shard = input_path.stem
+    out_dir = output_root / shard
+    out_dir.mkdir(parents=True, exist_ok=True)
+    started = time.perf_counter()
+    started_at = datetime.now(timezone.utc).isoformat()
+    input_rows = pq.ParquetFile(input_path).metadata.num_rows
+
+    t0 = time.perf_counter()
+    toxic = run_toxic_filters(
+        input_path=input_path,
+        output_root=out_dir / "toxic",
+        reference_dir=Path(config["reference_dir"]),
+        additional_dir=Path(config["additional_dir"]),
+        batch_size=config["batch_size"],
+        modes=[MODE],
+        exclude_dir=Path(config["exclude_dir"]),
+        blocklist=_WORKER["blocklist"],
+        cooccurrence=_WORKER["cooccurrence"],
+    )
+    toxic_seconds = time.perf_counter() - t0
+    toxic_mode = toxic["modes"][MODE]
+    retained_path = out_dir / "toxic" / MODE / "retained.parquet"
+
+    t0 = time.perf_counter()
+    pii = run_pii(
+        input_path=retained_path,
+        output_root=out_dir / "pii",
+        batch_size=config["batch_size"],
+        policy_approver=config.get("policy_approver"),
+        policy_approved_on=config.get("policy_approved_on"),
+        policy_note=config.get("policy_note"),
+    )
+    pii_seconds = time.perf_counter() - t0
+
+    final_path = out_dir / f"{shard}.parquet"
+    shutil.move(str(out_dir / "pii" / "pii_replaced" / "replaced.parquet"), str(final_path))
+    if not config.get("keep_intermediate"):
+        retained_path.unlink(missing_ok=True)
+    final_rows = pq.ParquetFile(final_path).metadata.num_rows
+
+    summary = {
+        "pipeline_version": PIPELINE_VERSION,
+        "shard": shard,
+        "input_file": str(input_path),
+        "input_rows": input_rows,
+        "started_at_utc": started_at,
+        "finished_at_utc": datetime.now(timezone.utc).isoformat(),
+        "seconds": {"toxic": round(toxic_seconds, 1), "pii": round(pii_seconds, 1), "total": round(time.perf_counter() - started, 1)},
+        "toxic": {
+            "mode": MODE,
+            "threshold": toxic_mode["threshold"],
+            "category_thresholds": toxic_mode.get("category_thresholds", {}),
+            "records_scanned": toxic_mode["total_records_scanned"],
+            "records_deleted": toxic_mode["records_deleted"],
+            "records_retained": toxic_mode["records_retained"],
+            "records_deleted_by_reason": toxic_mode["records_deleted_by_reason"],
+            "by_category": {c: {"records_with_match": v["records_with_match"], "records_deleted": v["records_deleted"]} for c, v in toxic_mode["by_category"].items()},
+            "domain_blocklist_by_source": {k: v for k, v in toxic_mode.get("domain_blocklist", {}).get("by_source", {}).items()},
+            "domain_blocklist_sources": toxic_mode.get("domain_blocklist", {}).get("sources"),
+            "cooccurrence_by_rule": {k: {"records_matched": v["records_matched"]} for k, v in toxic_mode.get("cooccurrence", {}).get("by_rule", {}).items()},
+            "wordlist_excluded_terms_by_category": toxic_mode.get("wordlist_excluded_terms_by_category"),
+            "wordlist_unique_terms_by_category": toxic.get("wordlist_unique_terms_by_category"),
+        },
+        "pii": {
+            "records_scanned": pii["total_records_scanned"],
+            "records_with_replacement": pii["records_with_replacement"],
+            "total_replacements": pii["total_replacements"],
+            "by_type": {k: {"records_with_match": v["records_with_match"], "replacement_count": v["replacement_count"]} for k, v in pii["by_type"].items()},
+            "policy": pii["pii_policy"],
+            "detector_version": pii.get("detector_version"),
+        },
+        "output": {
+            "cleaned_parquet": str(final_path),
+            "final_rows": final_rows,
+            "removed_jsonl": str(out_dir / "toxic" / MODE / "removed.jsonl"),
+            "cooccurrence_review_jsonl": str(out_dir / "toxic" / MODE / "cooccurrence_review.jsonl"),
+            "flagged_jsonl": str(out_dir / "toxic" / MODE / "flagged.jsonl"),
+            "borderline_jsonl": str(out_dir / "toxic" / MODE / "borderline.jsonl"),
+            "pii_audit_jsonl": str(out_dir / "pii" / "pii_replaced" / "audit.jsonl"),
+        },
+    }
+    (out_dir / "shard_summary.json").write_text(json.dumps(summary, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+    return summary
+
+
+def _worker_entry(args: tuple[str, str, dict[str, Any]]) -> dict[str, Any]:
+    input_path, output_root, config = args
+    try:
+        return process_shard(Path(input_path), Path(output_root), config)
+    except Exception as error:  # noqa: BLE001 - 1シャードの失敗で全体を止めない
+        return {"shard": Path(input_path).stem, "input_file": input_path, "error": repr(error), "traceback": traceback.format_exc()}
+
+
+class Uploader:
+    """完了したシャードのディレクトリをまとめて HF データセットへアップロードする。"""
+
+    def __init__(self, repo_id: str, prefix: str, output_root: Path, batch: int, delete_local: bool, private: bool = True) -> None:
+        from huggingface_hub import HfApi
+
+        self.api = HfApi()
+        self.repo_id = repo_id
+        self.prefix = prefix.strip("/")
+        self.output_root = output_root
+        self.batch = max(1, batch)
+        self.delete_local = delete_local
+        self.pending: list[str] = []
+        self.uploaded: list[str] = []
+        self.api.create_repo(repo_id, repo_type="dataset", private=private, exist_ok=True)
+
+    def existing_shards(self) -> set[str]:
+        files = self.api.list_repo_files(self.repo_id, repo_type="dataset")
+        marker = f"{self.prefix}/"
+        return {path[len(marker):].split("/", 1)[0] for path in files if path.startswith(marker) and path.endswith("/shard_summary.json")}
+
+    def add(self, shard: str) -> None:
+        self.pending.append(shard)
+        if len(self.pending) >= self.batch:
+            self.flush()
+
+    def flush(self) -> None:
+        if not self.pending:
+            return
+        shards = list(self.pending)
+        for attempt in range(5):
+            try:
+                self.api.upload_folder(
+                    repo_id=self.repo_id,
+                    repo_type="dataset",
+                    folder_path=str(self.output_root),
+                    path_in_repo=self.prefix,
+                    allow_patterns=[f"{shard}/**" for shard in shards],
+                    commit_message=f"add {len(shards)} shard(s): {shards[0]}..{shards[-1]}",
+                )
+                break
+            except Exception as error:  # noqa: BLE001
+                wait = 30 * (attempt + 1)
+                print(json.dumps({"event": "upload_retry", "attempt": attempt + 1, "error": repr(error), "wait_s": wait}), flush=True)
+                time.sleep(wait)
+        else:
+            raise RuntimeError(f"アップロードに失敗しました: {shards}")
+        self.uploaded.extend(shards)
+        self.pending.clear()
+        print(json.dumps({"event": "uploaded", "shards": shards, "repo": self.repo_id, "prefix": self.prefix}), flush=True)
+        if self.delete_local:
+            for shard in shards:
+                shutil.rmtree(self.output_root / shard, ignore_errors=True)
+
+
+def main(argv: list[str] | None = None) -> None:
+    source_dir = Path(__file__).resolve().parent
+    project_root = source_dir.parent
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    group = parser.add_mutually_exclusive_group(required=True)
+    group.add_argument("--input", type=Path, action="append", help="入力parquet（複数可）")
+    group.add_argument("--input-dir", type=Path, help="入力parquetのディレクトリ")
+    parser.add_argument("--pattern", default="*.parquet")
+    parser.add_argument("--limit-shards", type=int, default=None, help="先頭N件だけ処理する（試運転用）")
+    parser.add_argument("--output-root", type=Path, required=True)
+    parser.add_argument("--workers", type=int, default=max(1, (os.cpu_count() or 2) - 1))
+    parser.add_argument("--batch-size", type=int, default=2048)
+    parser.add_argument("--keep-intermediate", action="store_true", help="有害フィルタ後の retained.parquet を残す")
+    parser.add_argument("--reference-dir", type=Path, default=source_dir / "wordlists" / "reference")
+    parser.add_argument("--additional-dir", type=Path, default=source_dir / "wordlists")
+    parser.add_argument("--exclude-dir", type=Path, default=source_dir / "wordlists" / "exclude")
+    parser.add_argument("--blocklist-dir", type=Path, default=source_dir / "blocklists")
+    parser.add_argument("--blocklist-cache-dir", type=Path, default=project_root / "data" / "blocklists" / "ut1")
+    parser.add_argument("--no-blocklist", action="store_true")
+    parser.add_argument("--cooccurrence-rules", type=Path, default=source_dir / "wordlists" / "cooccurrence" / "rules.json")
+    parser.add_argument("--no-cooccurrence", action="store_true")
+    parser.add_argument("--policy-approver", default=None)
+    parser.add_argument("--policy-approved-on", default=None)
+    parser.add_argument("--policy-note", default=None)
+    parser.add_argument("--upload-repo", default=None, help="出力先の HF データセット（例: Podtech/abeja-cc-ja-cleaned）。非公開で作成する")
+    parser.add_argument("--upload-prefix", default="outputs", help="リポジトリ内のパス接頭辞（例: outputs/common_crawl_0）")
+    parser.add_argument("--upload-batch", type=int, default=5, help="何シャードごとに1コミットでアップロードするか")
+    parser.add_argument("--delete-local-after-upload", action="store_true")
+    parser.add_argument("--skip-existing-in-repo", action="store_true", help="リポジトリに shard_summary.json があるシャードを飛ばす")
+    args = parser.parse_args(argv)
+
+    if args.input_dir:
+        inputs = sorted(args.input_dir.glob(args.pattern))
+    else:
+        inputs = list(args.input)
+    if args.limit_shards is not None:
+        inputs = inputs[: args.limit_shards]
+    if not inputs:
+        raise FileNotFoundError("入力parquetが見つかりません")
+    args.output_root.mkdir(parents=True, exist_ok=True)
+
+    uploader = None
+    skip: set[str] = set()
+    if args.upload_repo:
+        uploader = Uploader(args.upload_repo, args.upload_prefix, args.output_root, args.upload_batch, args.delete_local_after_upload)
+        if args.skip_existing_in_repo:
+            skip = uploader.existing_shards()
+    todo = []
+    for path in inputs:
+        shard = path.stem
+        if shard in skip or (args.output_root / shard / "shard_summary.json").exists():
+            print(json.dumps({"event": "skip", "shard": shard}), flush=True)
+            continue
+        todo.append(path)
+
+    config = {
+        "batch_size": args.batch_size,
+        "keep_intermediate": args.keep_intermediate,
+        "reference_dir": str(args.reference_dir), "additional_dir": str(args.additional_dir), "exclude_dir": str(args.exclude_dir),
+        "blocklist_dir": str(args.blocklist_dir), "blocklist_cache_dir": str(args.blocklist_cache_dir), "no_blocklist": args.no_blocklist,
+        "cooccurrence_rules": str(args.cooccurrence_rules), "no_cooccurrence": args.no_cooccurrence,
+        "policy_approver": args.policy_approver, "policy_approved_on": args.policy_approved_on, "policy_note": args.policy_note,
+    }
+    run_started = time.perf_counter()
+    results: list[dict[str, Any]] = []
+    print(json.dumps({"event": "start", "shards": len(todo), "skipped": len(inputs) - len(todo), "workers": args.workers, "output_root": str(args.output_root)}), flush=True)
+    jobs = [(str(path), str(args.output_root), config) for path in todo]
+    if args.workers <= 1 or len(jobs) <= 1:
+        _init_worker(config)
+        iterator = map(_worker_entry, jobs)
+    else:
+        # pyarrow がスレッドを持つため fork は子プロセスのデッドロック要因になる。spawn で各ワーカーが独立に読み込む。
+        context = mp.get_context("spawn")
+        pool = context.Pool(processes=min(args.workers, len(jobs)), initializer=_init_worker, initargs=(config,))
+        iterator = pool.imap_unordered(_worker_entry, jobs)
+    for result in iterator:
+        results.append(result)
+        if "error" in result:
+            print(json.dumps({"event": "error", "shard": result["shard"], "error": result["error"]}), flush=True)
+            continue
+        print(json.dumps({
+            "event": "done", "shard": result["shard"], "input_rows": result["input_rows"],
+            "toxic_deleted": result["toxic"]["records_deleted"], "pii_replacements": result["pii"]["total_replacements"],
+            "final_rows": result["output"]["final_rows"], "seconds": result["seconds"]["total"],
+        }, ensure_ascii=False), flush=True)
+        if uploader is not None:
+            uploader.add(result["shard"])
+    if uploader is not None:
+        uploader.flush()
+    errors = [r for r in results if "error" in r]
+    run_summary = {
+        "pipeline_version": PIPELINE_VERSION,
+        "finished_at_utc": datetime.now(timezone.utc).isoformat(),
+        "shards_processed": len(results) - len(errors),
+        "shards_failed": [{"shard": r["shard"], "error": r["error"]} for r in errors],
+        "shards_skipped": len(inputs) - len(todo),
+        "seconds": round(time.perf_counter() - run_started, 1),
+        "upload_repo": args.upload_repo,
+        "upload_prefix": args.upload_prefix if args.upload_repo else None,
+    }
+    (args.output_root / f"run_summary_{datetime.now(timezone.utc).strftime('%Y%m%dT%H%M%SZ')}.json").write_text(json.dumps(run_summary, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+    print(json.dumps({"event": "finish", **run_summary}, ensure_ascii=False), flush=True)
+    if errors:
+        raise SystemExit(1)
+
+
+if __name__ == "__main__":
+    main()

code/e5cb5ca/src/sample_for_review.py

@@ -0,0 +1,177 @@
+"""目視確認と分類器用のサンプルを層別に抽出する（監査の第3手法の入口）。
+
+有害フィルタの出力（summary.json, removed.jsonl, borderline.jsonl,
+cooccurrence_review.jsonl）と元の入力parquetから、次の層でサンプルを取る。
+
+* ``deleted:<category>``      ワードリストで削除した文書（カテゴリ別、既定30件）
+* ``deleted:domain_blocklist`` ドメインブロックリストで削除した文書（既定30件）
+* ``cooccurrence:<rule>``     近接共起規則の一致（規則ごとに既定100件。一致文書は全件削除される）
+* ``borderline:<category>``   しきい値に1語足りず保持された文書（カテゴリ別、既定30件）
+* ``retained:random``         保持文書の無作為抽出（既定100件。見逃し率の推定に使う）
+
+出力は ``review_samples.csv``（人が判定を記入する）と ``review_samples.jsonl``
+（``classify_qwen3guard.py`` の入力）。抽出条件は ``sampling_manifest.json`` に残す。
+"""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import json
+import random
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+import pyarrow.parquet as pq
+
+from filter_toxic import CATEGORIES, KeywordMatcher, load_wordlists
+from textmatch import normalize
+
+
+CSV_COLUMNS = [
+    "sample_id", "stratum", "category", "record_index", "url", "matched_terms",
+    "excerpt", "reviewer", "verdict", "reason", "reviewed_at",
+]
+
+
+def _read_jsonl(path: Path) -> list[dict[str, Any]]:
+    if not path.exists():
+        return []
+    with path.open(encoding="utf-8") as handle:
+        return [json.loads(line) for line in handle if line.strip()]
+
+
+def _excerpt(text: str, positions: list[int], length: int = 300) -> str:
+    if not text:
+        return ""
+    if positions:
+        start = max(0, positions[0] - length // 3)
+    else:
+        start = 0
+    return text[start:start + length].replace("\n", " ")
+
+
+def main(argv: list[str] | None = None) -> None:
+    source_dir = Path(__file__).resolve().parent
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--input", type=Path, required=True, help="元の入力parquet")
+    parser.add_argument("--output-root", type=Path, required=True, help="main_toxic.py の --output-root")
+    parser.add_argument("--mode", default="distinct_terms_3plus")
+    parser.add_argument("--dest", type=Path, required=True, help="サンプルの出力先ディレクトリ")
+    parser.add_argument("--seed", type=int, default=20260904)
+    parser.add_argument("--deleted-per-category", type=int, default=30)
+    parser.add_argument("--deleted-domain", type=int, default=30)
+    parser.add_argument("--borderline-per-category", type=int, default=30)
+    parser.add_argument("--random-retained", type=int, default=100)
+    parser.add_argument("--cooccurrence-limit", type=int, default=100, help="共起規則ごとの抽出上限（既定100。全件にするには 0）")
+    parser.add_argument("--text-chars", type=int, default=4000, help="JSONLに含める本文の最大文字数")
+    parser.add_argument("--reference-dir", type=Path, default=source_dir / "wordlists" / "reference")
+    parser.add_argument("--additional-dir", type=Path, default=source_dir / "wordlists")
+    parser.add_argument("--exclude-dir", type=Path, default=source_dir / "wordlists" / "exclude")
+    args = parser.parse_args(argv)
+    rng = random.Random(args.seed)
+    mode_dir = args.output_root / args.mode
+    summary = json.loads((mode_dir / "summary.json").read_text(encoding="utf-8"))
+    threshold = summary["threshold"]
+    removed = _read_jsonl(mode_dir / "removed.jsonl")
+    borderline = _read_jsonl(mode_dir / "borderline.jsonl")
+    cooccurrence = _read_jsonl(mode_dir / "cooccurrence_review.jsonl")
+    removed_indices = {record["_filter_record_index"] for record in removed}
+    row_range = summary["row_range"]
+
+    samples: list[dict[str, Any]] = []
+
+    def add(stratum: str, category: str, record_index: int, url: str, terms: list[str], text: str, positions: list[int]) -> None:
+        samples.append({
+            "stratum": stratum, "category": category, "record_index": record_index, "url": url,
+            "matched_terms": terms, "text": text, "match_positions": positions,
+        })
+
+    # 削除文書（ワードリスト）
+    for category in CATEGORIES:
+        pool = [r for r in removed if category in r["_filter_deleted_categories"]]
+        for record in rng.sample(pool, min(args.deleted_per_category, len(pool))):
+            terms = record["_filter_distinct_matched_terms_by_category"].get(category, [])
+            text = normalize(record.get("content") or "")
+            positions = sorted(p for t in terms for p in [text.find(t)] if p >= 0)
+            add(f"deleted:{category}", category, record["_filter_record_index"], record.get("url") or "", terms, text, positions)
+    # 削除文書（ドメインブロックリスト）
+    pool = [r for r in removed if "domain_blocklist" in r.get("_filter_deleted_by", [])]
+    for record in rng.sample(pool, min(args.deleted_domain, len(pool))):
+        sources = sorted({m["source"] + "=" + m["matched"] for m in record.get("_filter_domain_matches", [])})
+        add("deleted:domain_blocklist", "domain_blocklist", record["_filter_record_index"], record.get("url") or "", sources,
+            normalize(record.get("content") or ""), [])
+    # 共起規則（既定は全件）
+    by_rule: dict[str, list[dict[str, Any]]] = {}
+    for item in cooccurrence:
+        by_rule.setdefault(item["rule"], []).append(item)
+    removed_by_index = {r["_filter_record_index"]: r for r in removed}
+    for rule, items in by_rule.items():
+        chosen = items if not args.cooccurrence_limit else rng.sample(items, min(args.cooccurrence_limit, len(items)))
+        for item in chosen:
+            record = removed_by_index.get(item["record_index"], {})
+            text = normalize(record.get("content") or "")
+            positions = [pair["position"] for pair in item["pairs"][:4]]
+            pairs = [f"{pair['a']}×{pair['b']}" for pair in item["pairs"][:5]]
+            add(f"cooccurrence:{rule}", item.get("label_ja", rule), item["record_index"], item.get("url") or "", pairs, text, positions)
+
+    # 保持文書は入力parquetから本文を取る
+    needed: dict[int, list[tuple[str, str, list[str]]]] = {}
+    for category in CATEGORIES:
+        pool = [b for b in borderline if category in b["categories"]]
+        for record in rng.sample(pool, min(args.borderline_per_category, len(pool))):
+            needed.setdefault(record["record_index"], []).append((f"borderline:{category}", category, record["categories"][category]))
+    retained_pool = [i for i in range(row_range["start_row_inclusive"], row_range["end_row_exclusive"]) if i not in removed_indices]
+    for record_index in rng.sample(retained_pool, min(args.random_retained, len(retained_pool))):
+        needed.setdefault(record_index, []).append(("retained:random", "random", []))
+    if needed:
+        table = pq.read_table(args.input, columns=["url", "content"])
+        wordlists = load_wordlists(args.reference_dir, args.additional_dir, args.exclude_dir)
+        matcher = KeywordMatcher(wordlists.terms, wordlists.sources)
+        for record_index, entries in sorted(needed.items()):
+            row = table.slice(record_index, 1).to_pylist()[0]
+            text = normalize(row.get("content") or "")
+            positions = sorted({found.start() for found in matcher.pattern.finditer(text)})[:8]
+            for stratum, category, terms in entries:
+                add(stratum, category, record_index, row.get("url") or "", terms, text, positions)
+
+    args.dest.mkdir(parents=True, exist_ok=True)
+    with (args.dest / "review_samples.csv").open("w", encoding="utf-8", newline="") as handle:
+        writer = csv.DictWriter(handle, fieldnames=CSV_COLUMNS)
+        writer.writeheader()
+        for number, sample in enumerate(samples, start=1):
+            sample_id = f"S{number:05d}"
+            sample["sample_id"] = sample_id
+            writer.writerow({
+                "sample_id": sample_id, "stratum": sample["stratum"], "category": sample["category"],
+                "record_index": sample["record_index"], "url": sample["url"],
+                "matched_terms": " | ".join(sample["matched_terms"]),
+                "excerpt": _excerpt(sample["text"], sample["match_positions"]),
+                "reviewer": "", "verdict": "", "reason": "", "reviewed_at": "",
+            })
+    with (args.dest / "review_samples.jsonl").open("w", encoding="utf-8") as handle:
+        for sample in samples:
+            handle.write(json.dumps({
+                "id": sample["sample_id"], "stratum": sample["stratum"], "category": sample["category"],
+                "record_index": sample["record_index"], "url": sample["url"], "matched_terms": sample["matched_terms"],
+                "match_positions": sample["match_positions"], "text": sample["text"][:args.text_chars],
+            }, ensure_ascii=False, separators=(",", ":")) + "\n")
+    strata: dict[str, int] = {}
+    for sample in samples:
+        strata[sample["stratum"]] = strata.get(sample["stratum"], 0) + 1
+    manifest = {
+        "created_at_utc": datetime.now(timezone.utc).isoformat(),
+        "input": str(args.input), "output_root": str(args.output_root), "mode": args.mode, "seed": args.seed,
+        "sizes": {"deleted_per_category": args.deleted_per_category, "deleted_domain": args.deleted_domain,
+                  "borderline_per_category": args.borderline_per_category, "random_retained": args.random_retained,
+                  "cooccurrence_limit": args.cooccurrence_limit},
+        "threshold": threshold, "strata": strata, "total_samples": len(samples),
+        "verdict_values": ["harmful", "not_harmful", "unsure"],
+    }
+    (args.dest / "sampling_manifest.json").write_text(json.dumps(manifest, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+    print(json.dumps({"total_samples": len(samples), "strata": strata}, ensure_ascii=False))
+
+
+if __name__ == "__main__":
+    main()

code/e5cb5ca/src/textmatch.py

@@ -0,0 +1,98 @@
+"""ワードリスト照合の共通部品。正規化、語リストの読み込み、境界付きトライ正規表現。
+
+``filter_toxic.py`` と ``cooccurrence.py`` の両方から使うため、循環importを
+避けて独立モジュールに置く。
+"""
+
+from __future__ import annotations
+
+import re
+import unicodedata
+from pathlib import Path
+from typing import Any
+
+
+ASCII_EDGE = "[a-z0-9]"
+KATAKANA_EDGE = "[ァ-ヶー]"
+
+
+def normalize(value: Any) -> str:
+    """ワードリストと本文を同じNFKC・小文字化規則で正規化する。"""
+
+    if value is None:
+        return ""
+    return unicodedata.normalize("NFKC", str(value)).lower()
+
+
+def read_terms(path: Path) -> list[str]:
+    """1行1語のリストを読み、正規化する。空行と``#``始まりの行は無視する。"""
+
+    if not path.exists():
+        return []
+    terms: list[str] = []
+    for raw_line in path.read_text(encoding="utf-8").splitlines():
+        term = normalize(raw_line.strip())
+        if term and not term.startswith("#"):
+            terms.append(term)
+    return terms
+
+
+def _edge_class(character: str) -> str | None:
+    """語の端の文字種。ASCII英数字とカタカナだけを境界判定の対象にする。"""
+
+    if re.fullmatch(ASCII_EDGE, character):
+        return ASCII_EDGE
+    if re.fullmatch(KATAKANA_EDGE, character):
+        return KATAKANA_EDGE
+    return None
+
+
+def compile_trie_pattern(terms: list[str], boundaries: bool = True) -> re.Pattern[str]:
+    """多数語を共通接頭辞付き正規表現へコンパイルする。
+
+    ``boundaries`` が真のとき、語の端がASCII英数字なら英数字が隣接する位置、
+    端がカタカナならカタカナ（長音を含む）が隣接する位置では一致させない。
+    「メイク」中の「イク」、「DVD」中の「dv」のような単語内部の部分一致を
+    防ぐ。漢字・ひらがなの端には境界を設けない。同じ位置では長い語を優先し、
+    長い語が境界を満たさない場合だけ短い語で境界を確認する。
+    """
+
+    if not terms:
+        return re.compile(r"(?!x)x")
+    root: dict[str, Any] = {"terminal": False, "children": {}}
+    for term in terms:
+        node = root
+        for character in term:
+            node = node["children"].setdefault(character, {"terminal": False, "children": {}})
+        node["terminal"] = True
+
+    def lookahead(character: str) -> str:
+        edge = _edge_class(character) if boundaries else None
+        return f"(?!{edge})" if edge else ""
+
+    def render(node: dict[str, Any], last_character: str) -> str:
+        branches = [
+            re.escape(character) + render(child, character)
+            for character, child in sorted(node["children"].items())
+        ]
+        if not branches:
+            body = ""
+        elif len(branches) == 1:
+            body = branches[0]
+        else:
+            body = "(?:" + "|".join(branches) + ")"
+        if not node["terminal"]:
+            return body
+        end = lookahead(last_character)
+        if not body:
+            return end
+        return "(?:" + body + "|" + end + ")"
+
+    alternatives: list[str] = []
+    for character, child in sorted(root["children"].items()):
+        edge = _edge_class(character) if boundaries else None
+        # 後読みは先頭文字を消費した後に置く。分岐が後読みで始まると
+        # 正規表現エンジンの先頭文字による走査最適化が効かず、約4倍遅くなる。
+        lookbehind = f"(?<!{edge}{re.escape(character)})" if edge else ""
+        alternatives.append(re.escape(character) + lookbehind + render(child, character))
+    return re.compile("(?:" + "|".join(alternatives) + ")")

code/e5cb5ca/src/wordlists/cooccurrence/ja_howto_terms.txt

@@ -0,0 +1,26 @@
+# 手引き（作り方・入手・回避）を示す語。報道で使われる「手口」、汎用の「手順」は含めない。
+作り方
+作成方法
+製造方法
+製造法
+製法
+精製方法
+精製法
+合成方法
+合成法
+栽培方法
+栽培法
+入手方法
+入手法
+購入方法
+買い方
+密輸方法
+やり方
+バレない
+ばれない
+バレずに
+足がつかない
+足のつかない
+摘発されない
+捕まらない
+逃れる方法

code/e5cb5ca/src/wordlists/cooccurrence/ja_illegal_object_terms.txt

@@ -0,0 +1,31 @@
+# 違法行為の対象語。手引き語との近接共起で用いる。
+# 「詐欺」「不正アクセス」「ランサムウェア」等は注意喚起・セキュリティ解説で「手順」「やり方」と
+# 共起しやすく誤検出が多いため2026-09-04に外した。サイバー系はワードリスト crime で扱う。
+覚醒剤
+覚せい剤
+麻薬
+大麻
+マリファナ
+コカイン
+ヘロイン
+mdma
+lsd
+危険ドラッグ
+脱法ハーブ
+違法薬物
+拳銃
+実銃
+改造銃
+爆弾
+爆発物
+火薬
+毒物
+青酸
+サリン
+偽札
+闇バイト
+密輸
+密売
+脱税
+マネーロンダリング
+資金洗浄

code/e5cb5ca/src/wordlists/cooccurrence/ja_minor_terms.txt

@@ -0,0 +1,23 @@
+# 未成年を示す語。「js」はJavaScriptと衝突するため含めない。ASCII語・カタカナ語には文字種境界が適用される。
+小学生
+中学生
+高校生
+女子高生
+女子中学生
+女子小学生
+男子高校生
+男子中学生
+女子高校生
+未成年
+未成年者
+児童
+幼女
+幼児
+園児
+ロリ
+ロリータ
+ランドセル
+jk
+jc
+女子生徒
+男子生徒

code/e5cb5ca/src/wordlists/cooccurrence/ja_sexual_terms.txt

@@ -0,0 +1,47 @@
+# 性的な文脈を示す語。未成年語との近接共起で用いる。
+セックス
+性行為
+性交
+性的
+挿入
+エロ
+わいせつ
+猥褻
+淫行
+淫ら
+ヌード
+全裸
+裸体
+オナニー
+フェラ
+手コキ
+中出し
+射精
+精液
+勃起
+ペニス
+膣
+乳首
+乳房
+おっぱい
+巨乳
+陰部
+性器
+下着姿
+パンチラ
+盗撮
+痴漢
+レイプ
+強姦
+援交
+援助交際
+パパ活
+売春
+買春
+風俗
+アダルト
+av女優
+adult
+porn
+sex
+hentai

code/e5cb5ca/src/wordlists/cooccurrence/rules.json

@@ -0,0 +1,22 @@
+{
+  "rules": [
+    {
+      "name": "minor_sexual_context",
+      "category": "adult_minor",
+      "label_ja": "未成年が登場する性的文脈",
+      "terms_a": "ja_minor_terms.txt",
+      "terms_b": "ja_sexual_terms.txt",
+      "window": 120,
+      "description_ja": "未成年を示す語と性的な語が120文字以内に共起する文書。監査項目5の『未成年が登場／読者として想定されている文脈は0件』を満たすため削除し、全件を目視確認する。事件報道や性教育も含まれ得るが、CPT用途では過剰削除を許容する。"
+    },
+    {
+      "name": "illegal_howto",
+      "category": "crime_howto",
+      "label_ja": "違法行為の手引き",
+      "terms_a": "ja_illegal_object_terms.txt",
+      "terms_b": "ja_howto_terms.txt",
+      "window": 40,
+      "description_ja": "薬物・武器・詐欺・不正アクセスの対象語と、作り方・入手方法・バレない方法などの手引き語が40文字以内に共起する文書。監査項目8の『手引き』を検出する。報道の『手口』は手引き語に含めない。"
+    }
+  ]
+}

code/e5cb5ca/src/wordlists/exclude/ja_adult_exclude.txt

@@ -0,0 +1,17 @@
+# 性的・わいせつカテゴリの除外語。既存リストは書き換えず、ここに載せた語だけを照合対象から外す。
+# 根拠: common_crawl_0_filtered_0001（10万文書）での文書頻度と文脈サンプル。
+# 漢字語は文字種境界が効かないため、他の語の内部に当たる汎用語を外す。
+# 文書頻度 1.36%。個性的・慢性的・理性的・女性的の内部一致が大半。
+性的
+# 文書頻度 0.70%。音痴・愚痴・乱痴気の内部一致。痴漢は別語として収録済み。
+痴
+# 文書頻度 0.42%。自傷・自殺は暴力カテゴリで扱う（そちらには残す）。
+自殺
+# ひらがな短語は動詞活用・助詞と衝突する（考えろ・答えろ、ころり・そろり、〜くんに、でっち上げ）。
+えろ
+ろり
+でり
+くんに
+でっち
+# 文書頻度 0.13%。「立ちはだかる」の内部一致が大半。
+はだか

code/e5cb5ca/src/wordlists/exclude/ja_crime_exclude.txt

@@ -0,0 +1,2 @@
+# 違法行為の手引きカテゴリの除外語。2026-09-04 のリスト再設計で汎用語（犯罪、drug など）を
+# リスト自体から外したため、現時点では除外語なし。

code/e5cb5ca/src/wordlists/exclude/ja_discrimination_exclude.txt

@@ -0,0 +1,5 @@
+# 差別・ヘイト・誹謗中傷カテゴリの除外語。既存リストは書き換えず、ここに載せた語だけを照合対象から外す。
+# 文書頻度 0.85%。「不具合」の内部一致がほぼ全て。
+不具
+# 文書頻度 0.14%。「詰めかけ」「諦めかけ」の内部一致が大半（妾のひらがな表記）。
+めかけ

code/e5cb5ca/src/wordlists/exclude/ja_propaganda_conspiracy_exclude.txt

@@ -0,0 +1,2 @@
+# 過激な政治・宗教プロパガンダ・陰謀論カテゴリの除外語。現時点では除外語なし。
+# 「カルト」「デマ」の単語内部一致（オカルト、オンデマンド）は文字種境界で防がれる。

code/e5cb5ca/src/wordlists/exclude/ja_spam_exclude.txt

@@ -0,0 +1,18 @@
+# スパムカテゴリの除外語。既存リストは書き換えず、ここに載せた語だけを照合対象から外す。
+# 根拠: common_crawl_0_filtered_0001（10万文書）での文書頻度と文脈サンプル。
+# 一般の販促・EC文脈で高頻度に出現し、単独ではスパム性を示さない語。
+# 文書頻度 7.46%（赤身肉に限定した、期間限定、数量限定、限定公開）
+限定
+# 文書頻度 3.76%（クリスマスプレゼント、入賞者へのプレゼント）
+プレゼント
+# 文書頻度 2.56%（キャッシュバックキャンペーン、イベント情報）
+キャンペーン
+# 文書頻度 0.93%（無料クーポン、ぐるなびのクーポン）
+クーポン
+# 主題語だが、資産運用・働き方ブログなど一般文脈が大半のため除外する（2026-09-04 方針決定）。
+# 文書頻度 0.71%（効率良く稼げる方法、安定して稼げるノウハウ）
+稼げる
+# 文書頻度 0.67%（本業×副業×投資、趣味から副業に）
+副業
+# 文書頻度 0.35%（短期売買のギャンブルをしない、ギャンブル依存症）
+ギャンブル

code/e5cb5ca/src/wordlists/exclude/ja_violence_exclude.txt

@@ -0,0 +1,26 @@
+# 暴力・自傷・自殺カテゴリの除外語。既存リストは書き換えず、ここに載せた語だけを照合対象から外す。
+# 根拠: common_crawl_0_filtered_0001（10万文書）での文書頻度と文脈サンプル。
+# 一般文脈（ニュース、医療、製品説明、日常会話）で高頻度に出現する汎用語。
+# 文書頻度 1.28%（細胞を破壊、破壊力を持つ企業）
+破壊
+# 文書頻度 0.46%。「破壊する」「崩壊する」の内部にも一致し、破壊と二重に数えられる。
+壊す
+# 文書頻度 1.24%（恐怖心、閉所恐怖症）
+恐怖
+# 文書頻度 1.11%（人はいずれ死ぬ、死ぬまで続く）
+死ぬ
+# 文書頻度 0.96%（犯罪抑止、犯罪の発生件数）。犯罪の手引きそのものは crime の専門語で判定する。
+犯罪
+# 文書頻度 0.60%（口喧嘩、恋人との喧嘩）
+喧嘩
+# 文書頻度 0.47%。「相殺する」「乳酸菌を殺す」の内部一致。
+殺す
+# 文書頻度 0.31%。「自殺した」「射殺した」の内部に一致し、自殺と二重に数えられる。
+殺した
+# 主題語だが、事件報道・小説・相談記事など一般文脈が大半のため除外する（2026-09-04 方針決定）。
+# 文書頻度 0.62%（性暴力の被害を告発、暴力的な排華運動）
+暴力
+# 文書頻度 0.49%（殺人未遂の疑いで、殺人教唆の証拠、ドラマ紹介）
+殺人
+# 文書頻度 0.42%（自殺予防に係る取組、事件報道）
+自殺

code/e5cb5ca/src/wordlists/ja_adult_keywords.txt

@@ -0,0 +1,10 @@
+ヌード
+r18
+porn
+児童買春
+性的搾取
+出会い系
+熟女
+エロ漫画
+アダルト動画
+素人娘

code/e5cb5ca/src/wordlists/ja_crime_keywords.txt

@@ -0,0 +1,54 @@
+# 違法行為の手引きカテゴリ（2026-09-04 再設計）。
+# 旧リストはサイバーセキュリティ用語中心で、セキュリティ企業の解説記事を削除していた。
+# 手引きそのものは cooccurrence/rules.json の illegal_howto（対象語×手引き語）で検出し、
+# このリストは違法市場・違法物の語が密集する文書（同一カテゴリ3語以上）の検出に用いる。
+# 一般報道で使われる「犯罪」「詐欺」「逮捕」は入れない。
+# --- 薬物 ---
+覚醒剤
+覚せい剤
+麻薬
+大麻
+マリファナ
+コカイン
+ヘロイン
+mdma
+危険ドラッグ
+脱法ハーブ
+違法薬物
+密売
+密輸
+# --- 武器・危険物 ---
+拳銃
+実銃
+改造銃
+爆弾
+爆発物
+火薬
+# --- 詐欺・不正取引 ---
+振り込め詐欺
+オレオレ詐欺
+特殊詐欺
+架空請求
+闇バイト
+受け子
+出し子
+偽札
+マネーロンダリング
+資金洗浄
+闇サイト
+ダークウェブ
+darkweb
+scam
+# --- 不正アクセス ---
+不正アクセス
+ハッキング
+クラッキング
+マルウェア
+ランサムウェア
+フィッシング
+hack
+# --- 窃盗・その他 ---
+万引き
+盗聴
+脱税
+横領

code/e5cb5ca/src/wordlists/ja_discrimination_keywords.txt

@@ -0,0 +1,11 @@
+誹謗中傷
+ヘイト
+人種差別
+性差別
+障害者差別
+レイシスト
+排外主義
+民族差別
+harassment
+優生思想
+クソガキ

code/e5cb5ca/src/wordlists/ja_propaganda_conspiracy_keywords.txt

@@ -0,0 +1,27 @@
+陰謀論
+イルミナティ
+ディープステート
+illuminati
+グレートリセット
+qアノン
+qanon
+カルト教団に洗脳
+ディープ・ステート
+ケムトレイル
+大覚醒
+deep state
+偽旗
+フェイクニュース
+デマ
+反ワクチン
+人口削減
+マイクロチップ
+グローバリスト
+新世界秩序
+nwo
+集団ストーカー
+カルト
+洗脳
+聖戦
+conspiracy
+new world order

code/e5cb5ca/src/wordlists/ja_spam_keywords.txt

@@ -0,0 +1,52 @@
+迷惑メール
+スパム
+今すぐ登録
+当選しました
+海賊版
+広告をクリック
+架空請求
+アダルトサイト
+違法ダウンロード
+投資詐欺
+crack
+必ず儲かる
+torrent
+フィッシングサイト
+絶対に儲かる
+cracked
+keygen
+アフィリエイト
+アフィカス
+副業
+高収入
+稼げる
+仮想通貨
+オンラインカジノ
+カジノ
+ギャンブル
+競馬
+パチンコ
+ポイントサイト
+クーポン
+キャンペーン
+懸賞
+プレゼント
+限定
+広告収入
+無料配布
+無料視聴
+違法コピー
+フィッシング
+アダルト
+ポルノ
+streaming
+casino
+bonus
+coupon
+affiliate
+scam
+phishing
+adult
+porn
+xxx
+warez

code/e5cb5ca/src/wordlists/ja_violence_keywords.txt

@@ -0,0 +1,31 @@
+自殺
+飛び降り
+bomb
+爆発物
+murder
+weapon
+首吊り
+リストカット
+暴行
+強姦
+強盗
+テロ
+刃物
+斬殺
+殺戮
+自爆
+殺害予告
+爆破
+銃器
+兵器
+dv
+torture
+terrorist
+assault
+shooting
+explosive
+stab
+stabbing
+hostage
+genocide
+テロリスト

code/e5cb5ca/src/wordlists/reference/ja_adult_keywords.txt

@@ -0,0 +1,1462 @@
+18+
+18禁
+20禁
+21禁
+3P
+48手
+AV女優
+AV男優
+AV監督
+Aカップ
+Bカップ
+Cカップ
+Dカップ
+D乳
+Eカップ
+Fカップ
+G spot
+Gすぽっと
+Gカップ
+Gスポ
+Gスポット
+HENTAI
+Holy Shit
+Hした
+Hしたい
+Hして
+Hしない?
+Hしよ
+Hしよっか
+Hする
+Hな
+Hな写
+Hに
+Hの
+Hを
+Hナ
+H中彼女
+H写
+H友達
+H声
+H好
+H画
+MANKO
+MANNKO
+M字
+OMANKO
+OMEKO
+Okamoto
+Onaho
+Onani
+SEX
+SMくらぶ
+SMぐっず
+SMクラブ
+SMグッズ
+SMプレイ
+SM俱樂部
+Sagami
+S○X
+TENGA
+Tバック
+asoko
+gすぽっと
+gスポット
+hしたい
+hする
+hな
+h写
+h好
+h画
+manko
+mannko
+sex
+smくらぶ
+xvideo
+あ○る
+あいえき
+あいこら
+あいぶ
+あえぎ
+あおかん
+あくめ
+あさだち
+あだると
+あなる
+あへ顔
+いぶつそうにゅう
+いまら
+いめーじくらぶ
+いらま
+いんけい
+いんこう
+いんぽ
+いんもう
+いんらん
+う ゙ぁぎな
+うらびでお
+ぇ□
+ぇっち
+ぇろ
+ぇ口
+え ろとーく
+え ろトーク
+え□
+え、ろとーく
+え〇すぎる
+えすえむ
+えちし
+えちな
+えっくすびでお
+えっち
+えねまぐら
+えろ
+えろい
+えろつべ
+えろ写メ
+えんこう
+えんじょ
+えんじょこうさい
+えッち
+え口
+お な に
+お○にー
+お●ぱい
+お◯にー
+おかもと
+おちOちん
+おちんこ
+おちんぽ
+おっP
+おっp
+おっπ
+おっさんとH
+おっぱい
+おっぱぶ
+おっパブ
+おとなのおもちゃ
+おな に
+おな○ー
+おなった
+おなでん
+おなに
+おなにほーる
+おなにー
+おなほ
+おなほーる
+おなる
+おなろう
+おな二
+おな写
+おな声
+おな好
+おな画
+おな系
+おな電
+おまnこ
+おまんこ
+おめこ
+おりえんと工業
+おるが
+おーがずむ
+お掃除フェラ
+かうぱー
+かり頭
+かわかぶり
+がんしゃ
+がんめんきじょうい
+き○たま
+きじょうい
+きっこうしばり
+きょこん
+きょちん
+きんたま
+くそまん
+くそマン
+くりとり
+くりとりす
+くわえ込む
+くんに
+けつ毛
+けつ穴
+こうしんこく
+こうないはっしゃ
+こうはいい
+こうび
+こうもん
+こかん
+こんどーむ
+ごうかん
+ごむしゃく
+ごむ尺
+さいいんざい
+さきばしりじる
+さきばしりぢる
+さげまん
+さんぴー
+ざーめん
+しおふき
+しこしこ
+しこる
+しっくすないん
+しゃぶる
+しょうにせいあい
+しょじょ
+しりがるおんな
+じゅうかん
+じょいん
+じょうふ
+すかと□
+すかとろ
+すかと口
+すかーとめくり
+すけこまし
+すけすけ
+すけべ
+すぺるま
+すまた
+ずっこんばっ婚
+ずりねた
+ずり仙人
+せ××す
+せ×くす
+せ○くす
+せ●くす
+せ❍くす
+せいいん
+せいえき
+せいかんまっさーじ
+せいかんヘルス
+せいき
+せいこう
+せいし
+せいじょうい
+せいどれい
+せいへき
+せいよく
+せくきゃば
+せくはら
+せくふれ
+せくろす
+せっ○す
+せっく○
+せっくす
+せふ○
+せふれ
+せんずり
+せックス
+ぜつりん
+ぜんぎ
+ぜんしんりっぷ
+そくはめ
+そーぷ
+そーぷらんど
+たちばっく
+たちまん
+たまきん
+たまなめ
+たまぶく
+たま舐め
+たんぽん
+だいいんしん
+だっちまん
+だっちわいふ
+だんこん
+ち○こ
+ち○ぽ
+ち●こ
+ち◯ぽ
+ちくび
+ちこう
+ちじょ
+ちじょくぷれい
+ちつがいしゃせい
+ちゃH
+ちんk
+ちん○ん
+ちん●ん
+ちんかす
+ちんぐり
+ちんげ
+ちんこ
+ちんちん
+ちんば
+ちんぴく
+ちんぼ
+ちんぽ
+ちんぽこ
+ちんぽろ
+ちんカス
+ちんポロ
+ちん毛
+ちーんこ
+てこき
+てまん
+てるH
+てれH
+てれくら
+てれふぉんくらぶ
+てれほんくらぶ
+てんが
+で●へる
+でぃるど
+でぃーぷきす
+でぃーぷすろーと
+でかちん
+でかまら
+でっち
+でり
+でりへる
+でんま
+とうさつ
+とるこじょう
+とるこぶろ
+とるこ嬢
+とるこ風呂
+どうてい
+どんびゃくしょう
+なかだし
+なかダシ
+なか出し
+なましゃく
+なまそうにゅう
+なま尺
+におうだちふぇら
+にくつぼ
+にくべんき
+にくぼう
+にっぷる
+にょいん
+にょたいもり
+ぬれぬれ
+ぬーど
+のぞきべや
+のぞき部屋
+はだか
+はってん場
+はぷにんぐば
+はみちん
+はみ毛
+はめっこ
+はめどり
+はめ倒し
+はめ写メ
+はめ撮り
+ばいあぐら
+ばいぶ
+ばーじん
+ぱ●てぃ
+ぱいおつ
+ぱいすら
+ぱいずり
+ぱいぱん
+ぱつぱつ
+ぱんすけ
+ぱんつ
+ぱんつ丸見え
+ひとりH
+ひとりエッチ
+ひにん
+びっち
+びらびら
+びーちく
+ぴ●さろ
+ぴすとん
+ぴんくさろん
+ぴんくろーた
+ぴんさろ
+ふぁっく
+ふうぞく
+ふぇら
+ふぇらち
+ふたなり
+ふにゃちん
+ふーぞく
+ぶてぃっくほてる
+ぶらじゃー
+ぶらちら
+ぷっしー
+へるす
+へんたい
+べろちゅー
+ぺってぃんぐ
+ぺどふぃりあ
+ぺにす
+ぺにすばんど
+ぺにすりんぐ
+ぺにばん
+ほてとる
+ほてへる
+ほんさろ
+ぼっき
+ぽこちん
+ぽるちお
+ぽるの
+ぽろり
+ぽんびき
+ぽん引き
+ま○こ
+ま●こ
+ま〇汁
+まいるーら
+まえつき
+まぐわい
+まさぐり
+まじっくみらー号
+ますかき
+ますたーべーしょん
+まぞ
+まな板ショー
+まむこ
+まんP
+まん〇
+まんかす
+まんぐりがえし
+まんぐり返し
+まんげ
+まんこ
+まんしゅう
+まんじる
+まんすじ
+まんちょ
+まんちん
+まんまん
+まんカス
+まん写
+まん形
+まん拓
+まん毛
+まん汁
+まん臭
+みるくたんく
+むしゅうせい
+むちむち
+むっちり
+むらむら
+めこすじ
+めこ筋
+めちゃしこ
+めちゃシコ
+もざいく
+もっこり
+もりまん
+もろだし
+やり×ん
+やりさー
+やりちん
+やりとも
+やりまん
+やりコン
+やりチン
+やりマン
+やり友
+やり逃げ
+ゆびまん
+ゆるまん
+ゆるマン
+ょぅΙ゙ょ
+ようじょ
+らぶほ
+らぶほーる
+らんこう
+りあるH
+りあるh
+りあるでH
+りょな
+れ○ぷ
+れ●ぷ
+れいぱー
+れいぷ
+ろり
+ろりこん
+ろりぺど
+ろりーた
+ろーたー
+わいせつ
+わかめ酒
+わぎな
+ア○ル
+ア●ル
+アイコラ
+アエギ
+アクメ
+アサダチ
+アス
+アスホール
+アダルト
+アダルトコーナー
+アダルトチャット
+アダルトビデオ
+アナニー
+アナル
+アナルSEX
+アナルセックス
+アナルバイブ
+アナルバージン
+アナルパール
+アナルファック
+アナルフィスト
+アナルプレイ
+アナル拡張
+アナル舐め
+アニリングス
+アヌス
+アブノーマル
+アヘ顔
+アースホール
+イキ顔
+イク
+イマラ
+イマラチオ
+イメクラ
+イメージクラブ
+イラマ
+イラマチオ
+インケイ
+インコウ
+インポ
+インモウ
+インラン
+ウ ゙ぁぎな
+ウ ゙ァギナ
+ウ○コ
+ウ●コ
+ウラdvd
+ェ□
+ェロ
+ェ口
+エ ロトーク
+エ ロ写メ
+エ ロ話
+エ□
+エ、ロトーク
+エ〇
+エ〇すぎる
+エっち
+エっチ
+エクスタシー
+エスエム
+エチ
+エチし
+エチな話
+エックスビデオ
+エッチ
+エッチな話
+エネマグラ
+エロ
+エロイプ
+エロエロ
+エロゲ
+エロシャメ
+エロス
+エロティック
+エロトーク
+エロ写メ
+エロ動画
+エロ画像
+エロ話
+エンコウ
+エンコー
+エンジョ
+エンジョコウサイ
+エ口
+オ○ニー
+オ●ニー
+オ◯ニー
+オカモト
+オチンコ
+オチンチン
+オチンポ
+オッπ
+オッパイ
+オナ
+オナ○ー
+オナった
+オナでん
+オナる
+オナろう
+オナクラ
+オナニ
+オナニスト
+オナニホール
+オナニー
+オナペット
+オナホ
+オナホール
+オナロウ
+オナ二
+オナ写
+オナ動
+オナ声
+オナ好
+オナ画
+オナ禁
+オナ系
+オナ電
+オフパコ
+オマ○コ
+オマンコ
+オマンマン
+オメコ
+オリエント工業
+オルガ
+オルガズム
+オーガズム
+オーラルセックス
+オールヌード
+カウパー
+カウパー氏腺液
+カップル喫茶
+カリ頭
+カント
+カンノウ
+ガチムチ
+ガマン汁
+ガンシャ
+ガンメンキジョウイ
+ガーターベルト
+キ○タマ
+キジョウイ
+キチガイ
+キッコウシバリ
+キメオナ
+キメセク
+キャバクラ
+キョコン
+キョチン
+キョニュウ
+キンタマ
+ク○ニ
+ク●ニ
+クソ
+クチュクチュ
+クリトリ
+クリトリス
+クロンボ
+クンニ
+クンニリングス
+クン二
+グチュグチュ
+ケチャマン
+ケツマンコ
+ケツ毛
+ケツ穴
+コウナイハッシャ
+コウビ
+コウモン
+コカン
+コンドーム
+コーマン
+ゴウカン
+ゴム尺
+サイインザイ
+サガミ
+サック
+サド
+サノバビッチ
+サンオブアビッチ
+サンピー
+サン・オブ・ア・ビッチ
+ザーメン
+シオフキ
+シコる
+シコシコ
+シックスナイン
+シット
+シャブる
+ショジョ
+ショタ
+シリガルオンナ
+シーメール
+ジイ
+ジャップ
+ジースポット
+スカト□
+スカトロ
+スカト口
+スカルファック
+スカートめくり
+スクリューユー
+スク水
+スケベ
+スケベイス
+スケベ椅子
+ストッキング
+ストリッパー
+ストリップ
+スパンキング
+スペルマ
+スマゲッチュ
+スマタ
+スマムビ
+スラット
+スワッピング
+ズッコンバッ婚
+ズリネタ
+セ××ス
+セ×クス
+セ○クス
+セ○レ
+セ◎レ
+セ●クス
+セ●レ
+セ❍クス
+セイイン
+セイエキ
+セイカンマッサージ
+セイキ
+セイコウ
+セイコウイ
+セイシ
+セイジョウイ
+セイドレイ
+セイヘキ
+セイヨク
+セクキャバ
+セクキャブ
+セクフレ
+セクロス
+セクース
+セッ○ス
+セッ●ス
+セックス
+セックスフレンド
+セフ○
+セフ◎
+セフ●
+セフレ
+センズリ
+ゼツリン
+ゼンギ
+ゼンシンリップ
+ゼンラ
+ソ○プ
+ソクハメ
+ソープ
+ソープランド
+タチバック
+タチマン
+タマキン
+タマナメ
+タンポン
+ダッチ
+ダッチマン
+ダッチワイフ
+ダンコン
+チ○コ
+チ○ポ
+チ●コ
+チ◯ポ
+チクニー
+チクビ
+チジョクプレイ
+チツ
+チツガイシャセイ
+チツナイシャセイ
+チャH
+チン○
+チン●ン
+チンかす
+チンぐり返し
+チンぽろ
+チンカス
+チングリ
+チンゲ
+チンコ
+チンチン
+チンピク
+チンボ
+チンボコ
+チンポ
+チンポコ
+チンポロ
+チンマン
+チン毛
+ツルマン
+ティムポ
+テコキ
+テマン
+テルH
+テルエッチ
+テレH
+テレエッチ
+テレクラ
+テレフォンクラブ
+テレフォンセックス
+テレホンH
+テレホンクラブ
+テレホンクラブ "
+テレホンセックス
+テンガ
+デ●ヘル
+ディック
+ディックヘッド
+ディルド
+ディルドー
+ディープキス
+ディープスロート
+デカチン
+デカマラ
+デリ
+デリバリーヘルス
+デリヘル
+デリ嬢
+デンマ
+デートクラブ
+トウサツ
+トップレス
+トルコ嬢
+トルコ風呂
+ドm
+ドウテイ
+ナカだし
+ナカダシ
+ナカ出し
+ナンパ
+ニオウダチフェラ
+ニガ
+ニガー
+ニクツボ
+ニクベンキ
+ニクボウ
+ニップル
+ニューハーフ
+ニョイン
+ニョタイモリ
+ヌいて
+ヌキキャバ
+ヌーディスト
+ノゾキベヤ
+ノゾキ部屋
+ノンケ
+ノーパン
+ノーブラ
+ハ○撮り
+ハイレグ
+ハッテン場
+ハプニング
+ハプニングバ
+ハプニングバー
+ハミ乳
+ハミ毛
+ハメたい
+ハメて
+ハメどり
+ハメまくる
+ハメる
+ハメドリ
+ハメハメ
+ハメ倒し
+ハメ写メ
+ハメ撮り
+バイアグラ
+バイブ
+バイブレーター
+バガー
+バキュームフェラ
+バクニュウ
+バスタード
+バター犬
+バージン
+パ●ティ
+パイずり
+パイちら
+パイもみ
+パイオツ
+パイスラ
+パイズリ
+パイパン
+パイ舐め
+パパ活
+パンちら
+パンもろ
+パンツ丸見え
+ヒトリH
+ヒトリえっち
+ヒトリエッチ
+ヒモパン
+ヒンニュウ
+ビクビク
+ビッチ
+ビーチク
+ピ●サロ
+ピス
+ピストン
+ピンクサロン
+ピンクロータ
+ピンクローター
+ピンサロ
+ピンサ口
+フ○ラ
+フ●ラ
+ファッキング
+ファック
+ファックユー
+ファッションヘルス
+フィストファック
+フィンガーファック
+フウゾク
+フェチ
+フェラ
+フェラチ
+フェラチオ
+フニャチン
+フリチン
+フーゾク
+フードル
+ブティックホテル
+ブラチラ
+ブルセラ
+ブロージョブ
+プッシー
+ヘルス
+ヘンタイ
+ベロシャ
+ベロチュー
+ベロ射
+ペ○ス
+ペ●ス
+ペッサリー
+ペッティング
+ペドフィリア
+ペニス
+ペニスバンド
+ペニスリング
+ペニバン
+ホテトル
+ホテヘル
+ホンサロ
+ホーリーシット
+ボイン
+ボッキ
+ポコチン
+ポルチオ
+ポルノ
+ポロリ
+ポンビキ
+ポーン
+マ○コ
+マ◎コ
+マ●コ
+マ◯コ
+マ〇汁
+マイクロビキニ
+マイルーラ
+マザーファッカー
+マザーファッキング
+マザーファック
+マジックミラー号
+マスかき
+マスターベーション
+マゾ
+マットプレイ
+マットヘルス
+ママ活
+マムコ
+マラ
+マンP
+マン〇
+マンかす
+マンぐり返し
+マンカス
+マングリがえし
+マングリガエシ
+マングリ返し
+マンゲ
+マンコ
+マンジル
+マンスジ
+マンチョ
+マンチン
+マン写
+マン形
+マン拓
+マン毛
+マン汁
+マン臭
+ミミズ千匹
+ミルクタンク
+ムシュウセイ
+ムチムチ下半身
+ムラムラ
+メ○スジ
+メコ○ジ
+メコスジ
+メコ筋
+メチャシコ
+モリマン
+モロ出し
+モロ画像
+モロ見え
+ヤりたい
+ヤガイセックス
+ヤリ×ン
+ヤリちん
+ヤリまん
+ヤリコン
+ヤリサー
+ヤリチン
+ヤリトモ
+ヤリマン
+ヤリモク
+ヤリ友
+ユビマン
+ユルマン
+ヨウジョ
+ライブチャット
+ラブジェル
+ラブジュース
+ラブドール
+ラブホ
+ラブホテル
+ラブホール
+ランコウ
+ランジェリーパブ
+ランパブ
+リアH
+リアルH
+リアルで
+リアルでH
+リアルエッチ
+リアルデH
+リョナ
+ルンペン
+レ○プ
+レ●プ
+レイパー
+レイプ
+レズ
+ロリ
+ロリコン
+ロリペド
+ロリータ
+ローター
+ワカメ酒
+ワキ毛
+ワギナ
+ヱロ
+ヴぁぎな
+ヴァギナ
+ヴァージン
+ㄘんㄘん
+一人H
+一人えっち
+一人エッチ
+一物
+丁稚
+三こすり半
+三助
+三所攻め
+三角木馬
+下乳
+下女
+下男
+不倫
+不貞
+両刀使い
+両刀遣い
+中○生
+中だし
+中ダシ
+中出し
+乱パ
+乱交
+乳房まっさーじゃー
+乳房マッサージャー
+乳控
+乳推
+乳揺れ
+��輪
+乳首
+亀甲
+亀甲しばり
+亀甲縛り
+亀頭
+二次画像
+交差位
+人妻
+仁王立ちフェラ
+会ってエッチ
+会陰部
+体位
+何かっぷ
+何カップ
+個ちゃ
+側位
+側室
+催淫
+催淫劑
+元気汁
+先走り汁
+先走り液
+先走リ汁
+児ぽ
+児ポ
+児童ぽるの
+児童ポルノ
+全裸
+全身リップ
+八の字筋
+公開テレクラ
+円光
+凌辱
+処女
+処女膜
+出張ヘルス
+初夜
+剃毛
+前戯
+前立腺
+前立腺マッサージ
+割れ目
+勃ってる
+勃起
+包茎
+千摺り
+半乳
+卑猥
+即はぼ
+即ぼん
+即ハボ
+即ハメ
+即ボン
+即尺
+卵子
+口まん
+口マン
+口交
+口内射精
+口内発射
+口射
+口暴
+口淫
+合法ドラッグ
+同性愛
+吹簫
+周旋屋
+和姦
+喘ぎ
+喘ぎ声
+喘ぐ
+喘げ
+喘ギ
+回春
+売女
+売春
+壺洗い
+处女
+変態
+夜這い
+夢精
+大人のおもちゃ
+大人ノオモチャ
+夫婦交換
+女のけつ
+女のケツ
+女中
+女体
+女体もり
+女体盛り
+女傑
+女給
+女衒
+女装
+女陰
+妃殿下
+妄撮
+妊婦とH
+妾
+姉妹丼
+姦
+姦通
+姫始め
+姫始メ
+姫納め
+姫納メ
+娼婦
+媚薬
+子宮
+官能
+宝味
+寝取
+対面座位
+射精
+小○生
+小児性愛
+小陰唇
+尺八
+尻の穴
+尻穴
+屈曲位
+屍姦
+工□
+工っち
+工ろ
+工ッチ
+工ロ
+工口
+巨チン
+巨万
+巨乳
+巨根
+幼児プレイ
+幼女
+床上手
+座位
+後背位
+得ロ
+微乳
+心障児
+心障者
+性さーびす嬢
+性サービス嬢
+性交
+性器
+性奴隷
+性感
+性感ヘルス
+性感マッサージ
+性暴力
+性欲
+性生活
+性病
+性癖
+性的
+性虐待
+性行為
+恥垢
+恥毛
+恥辱
+恥部
+恥骨
+情夫
+情婦
+惨殺
+愛奴
+愛撫
+愛汁
+愛液
+我慢汁
+手こき
+手でこきこき
+手でコキコキ
+手ぶら
+手まん
+手ん棒
+手コキ
+手マン
+手棒
+手淫
+抜きキャバ
+抜き尺
+指まん
+指マン
+挿入
+排尿
+援 交
+援○
+援●
+援コー
+援交
+摩羅
+放尿
+数の子天井
+早漏
+春画
+朝勃ち
+朝立ち
+朝起ち
+本さろ
+本サロ
+本気汁
+松葉崩し
+梅毒
+欲情
+欲求不満
+正常位
+死姦
+母娘丼
+水着居酒屋
+汁男優
+汚辱
+泡姫
+泡踊り
+洋ピン
+洋モノ
+浣腸
+海綿体
+淋病
+淫
+淫ら
+淫乱症
+淫叫
+淫夢
+淫婦
+淫慾
+淫欲
+淫水
+淫液
+淫祠
+淫虐
+淫語
+淫靡
+淫魔
+潮吹
+潮吹き
+潮吹水
+濡らす
+濡れる
+濡れ場
+濡れ濡れ
+炉利
+無修正
+爆乳
+犯したい
+犯してやる
+犯す
+犯る
+犯ス
+犯ル
+猥褻
+猥談
+獣交
+獣姦
+獣欲
+獸交
+獸姦
+玉舐め
+玉袋
+生H
+生でやって
+生でヤッて
+生ハメ
+生パン
+生尺
+生挿入
+男女の行為
+男根
+痴
+痴漢
+発情
+皮かぶり
+皮被り
+盗撮
+着衣セックス
+睾丸
+短小
+破廉恥
+破瓜
+神待ち
+秘所
+秘部
+種付け
+穴兄弟
+空気人形
+立ちばっく
+立ちまん
+立ちバック
+立ちマン
+立位
+童貞
+竿姉妹
+第一ちんぽ汁
+第一チンポ汁
+筆おろし
+筆下ろし
+粗ちん
+粗チン
+精えき
+精子
+精液
+精薄
+精飲
+素股
+絶倫
+緊縛
+美乳
+聖女
+聖水
+肉体関係
+肉便器
+肉壷
+肉壺
+肉奴隷
+肉棒
+肉欲
+肛交
+肛門
+股間
+胸チラ
+脱糞
+脳膜炎
+膜つき
+膣
+自慰
+自殺
+興奮劑
+舌まん
+舌マン
+舌入れ
+舌技
+花びら回転
+菊門
+虚乳
+虹画像
+虹百合
+蜜壺
+表日本
+裏DVD
+裏サイト
+裏スジ
+裏ビデオ
+裏動画
+裏本
+裏画像
+裏筋
+触手
+豊満熟女
+貧乳
+買春
+赤ちゃんプレイ
+足こき
+足コキ
+輪姦プレイ
+逆援
+遅漏
+避妊具
+野外SEX
+野外セックス
+野外プレイ
+金玉
+陰唇
+陰嚢
+陰囊
+陰核
+陰根
+陰毛
+陰茎
+陰部
+陵辱
+隠し撮り
+集団H
+雌豚
+電ま
+電マ
+電動こけし
+電動でぃるど
+電動オナホール
+電動コケシ
+電動ディルド
+電動陰莖
+顏射
+顔射
+顔面騎乗
+顔騎
+風俗
+飲尿
+騎上位
+騎乗位
+鬼畜
+魔羅
+黄金水
+龜頭

code/e5cb5ca/src/wordlists/reference/ja_discrimination_keywords.txt

@@ -0,0 +1,150 @@
+アイヌ系
+アカ
+アメ公
+アル中
+イカサマ
+イタ公
+イモ
+インチキ
+インディアン嘘つかない
+エスキモー
+エチゼンクラゲ
+オカマ
+オールドミス
+カッペ
+ガキ
+ガサ
+キ●ガイ
+キチ
+キチガ●
+キチガイ
+キ印
+ゲンナマ
+コロシ
+ゴミ屋
+サツ
+サラ金
+ザギン
+シマ
+ジプシー
+ジャップ
+ジャリ
+スケ
+スチュワーデス
+スラム
+ズージャー
+タケノコ医者
+ダッチマン
+チビ
+チャリンコ
+チャンコロ
+チョン
+デカ
+トルコ嬢
+トルコ風呂
+ドヤ街
+ナオン
+ニガー
+ニグロ
+ニコヨン
+ノビ
+バタ屋
+パクる
+パン助
+パーマ屋
+ヒモ
+ブス
+ブタ箱
+ブツ
+ブラインドタッチ
+ポコペン
+ポリ公
+マンコ
+ヤンキー
+ヤー様
+ヨツ
+ルンペン
+レントゲン技師
+ロンパリ
+丁稚
+三つ口
+三助
+三国人
+三韓征伐
+上方の贅六
+下女
+下男
+不具
+不可触民
+不治の病
+中共
+乞食
+二号
+人夫
+人足
+人非人
+他力本願
+代書屋
+令嬢
+伊勢乞食
+低脳
+低脳児
+低開発国
+保母
+保線工夫
+借り腹
+健全なる精神は健全なる身体に宿る
+傴僂
+八百屋
+共稼ぎ
+処女作
+処女峰
+出戻り
+出稼ぎ
+助産婦
+労務者
+北鮮
+千摺り
+ナオン
+ヒモ
+オールドミス
+女子供
+狂女
+下女
+下男
+女給
+女傑
+女工
+処女作
+処女峰
+女中
+スケ
+端女
+醜男
+阿婆擦れ
+男のくせに
+女のくせに
+男らしく
+女らしく
+女々しい
+女だてらに
+男勝り
+紅一点
+女の腐ったような
+女の腐ったの
+売れ残り
+出戻り
+めかけ
+職場の花
+二号さん
+フェミナチ
+あげまん
+さげまん
+あげちん
+さげちん
+まんこ
+ちんこ
+ビッチ
+毒女
+鬼女
+ババア

code/e5cb5ca/src/wordlists/reference/ja_violence_keywords.txt

@@ -0,0 +1,73 @@
+監禁
+生き埋め
+失血死
+死刑
+はりつけ
+死ね
+恫喝
+殺人鬼
+4ね
+4ぬ
+リンチ
+●す殺す
+レイプ
+殺人
+暴力
+溺死
+暴言
+麻薬
+氏ね
+虐殺
+パワハラ
+死ぬ
+いじめ
+銃撃
+殺す
+恐喝
+蹴り
+ガス室
+犯罪
+毒殺
+縊死
+武力
+処刑
+散弾銃
+腹切り
+拷問
+マフィア
+薬殺
+殴る
+脅迫
+感電死
+刺殺
+根性焼き
+焼死
+射殺
+拉致
+焼き殺し
+やくざ
+タヒね
+殺した
+核兵器
+撲殺
+ヤクザ
+絞殺
+壊す
+火あぶり
+恐怖
+皆殺し
+拳銃
+虐待
+893
+イジメ
+破壊
+殴打
+火炙り
+銃殺
+罵倒
+仕返し
+危険ドラッグ
+喧嘩
+串刺し
+殺意
+流血