DE-SN amending acts densify: +1,376 laws / +3,630 articles (append-only at 92488791; live rows byte-identical); added/not-added/known-gap manifests

README.md

@@ -37,12 +37,12 @@ Bremen (DE-HB) was collected but is **held back** pending a licence review (see
 
 | Field | Value |
 | --- | --- |
-| Snapshot date | 2026-09-05 (federal); Landesrecht 2026-10-02; DE-SN densify 2026-10-15; DE-SN heading/HTML fix 2026-10-15; contents/titles fix 2026-10-15; SN law-text line breaks 2026-10-15 |
+| Snapshot date | 2026-09-05 (federal); Landesrecht 2026-10-02; DE-SN densify 2026-10-15; DE-SN heading/HTML fix 2026-10-15; contents/titles fix 2026-10-15; SN law-text line breaks 2026-10-15; DE-SN amending acts 2026-10-17 |
 | Coverage | full Bundesrecht via gesetze-im-internet.de TOC |
 | Source | Bundesministerium der Justiz / gesetze-im-internet.de |
 | Collector | `scrapers/collect_gii.py` |
-| Laws / instruments | 10953 (federal 6127 + Landesrecht 4826) |
-| Articles | 209481 (federal 129124 + Landesrecht 80357) |
+| Laws / instruments | 12329 (federal 6127 + Landesrecht 6202) |
+| Articles | 213111 (federal 129124 + Landesrecht 83987) |
 | Language | de |
 | Jurisdiction | Germany (`DE` federal; `DE-<Land>` Landesrecht) |
 | License | `urhg-5-amtliche-werke` |
@@ -61,6 +61,7 @@ Bremen (DE-HB) was collected but is **held back** pending a licence review (see
 - `manifests/fix_sn_headings_ids.jsonl` — every DE-SN law/article id changed by the 2026-10-15 heading/HTML fix, with the action taken; `manifests/fix_sn_headings_REPORT.json` — invariants and gate results.
 - `manifests/fix_contents_titles_ids.jsonl` — every article row dropped and every title restored by the 2026-10-15 contents/titles fix, plus each law whose article_count changed; `manifests/fix_contents_titles_REPORT.json` — invariants and gate results.
 - `manifests/fix_sn_lawtext_br_ids.jsonl` — the DE-SN law texts whose line breaks were restored on 2026-10-15, with offsets and before/after snippets; `manifests/fix_sn_lawtext_br_REPORT.json` — invariants and gate results.
+- `manifests/densify_sn_amending_added_ids.jsonl` — every law and article id added by the DE-SN amending-acts densify (2026-10-17); `manifests/densify_sn_amending_known_gaps.jsonl` — rows of those laws dropped by the clean-up (with reason) and the repeal placeholders kept; `manifests/densify_sn_amending_not_added.jsonl` — collected records not added (duplicates of live rows; pages with no norm text).
 - `MANIFEST.md`, `PACK_META.json` — records of the 2026-10-02 Landesrecht append (not updated for later densify batches).
 
 ## License / reuse
@@ -215,3 +216,33 @@ Totals after the contents/titles fix: 10,953 laws / 209,481 articles.
 - In 24 DE-SN law texts the 2026-10-15 heading/HTML fix had removed 34 line breaks (`<br>`) that sat directly between two words, joining them (e.g. `elektronischenInformations-`). Each is a line break again, at the exact position taken from the raw text before that fix; offsets and before/after snippets are in `manifests/fix_sn_lawtext_br_ids.jsonl`.
 - No other field or row changed; law and article counts are unchanged.
 - Note: the bundled `scrapers/de_lib.py` still has default `HUB_TIP` f9384361 (an earlier tip). Set `DE_HUB_TIP` to the current tip before building a new pack, as the scrapers README says.
+
+## DE-SN amending acts densify — 2026-10-17 (1,376 laws / 3,630 articles, append-only at 92488791)
+
+- Source: www.revosax.sachsen.de (revosax); licence: Public domain (gemeinfrei): amtliche Werke i.S.d. § 5 Abs. 1 UrhG; Sächsische Staatskanzlei / revosax.sachsen.de (REVOSax)
+- Kinds: {"amending": 1376} — Änderungs-/Aufhebungsgesetze and -verordnungen (`metadata_json.metadata.kind` = `amending`), which the 2026-10-02 append and the 2026-10-15 densify excluded.
+- Every live row is byte-identical and comes first; only rows are appended (no live row changed or removed). New law and article ids are unique and disjoint from the tip; `article_count` = article rows for every added law.
+- Not added: 2,041 collected records are **duplicates of live rows** (1,666 id_on_tip, 375 same_title_same_land_on_tip); listed in `manifests/densify_sn_amending_not_added.jsonl`. (Earlier build logs called these 'dropped'; they are not bounds rejections.)
+- Not added: 2,003 REVOSax pages carry no norm text of their own (text under 80 characters; stub pages that only point to a parent act, e.g. `Gesetz zum Zehnten Rundfunkänderungsstaatsvertrag`); listed in the same manifest.
+- Clean-up (pipeline, added rows only): revosax footnotes are `[n]` markers plus a plain-text `Fußnoten:` block (16 article rows, 0 law texts converted at pack time); 18 structural heading rows (Teil/Abschnitt/Zustimmungsgesetz, or an `Artikel N` heading over the § rows of the act it contains) folded into the next row; 0 titles cleaned; 0 metadata fields cleaned of HTML. An empty `Artikel N` heading is never merged into Artikel N+1: each Artikel keeps its own text.
+- Repeal placeholders kept: 5 rows such as `Artikel 7 (außer Kraft)` / `(aufgehoben)` stay as rows, with stray footnote digits removed and `metadata_json.body_status` = `repealed_placeholder` (no new column; the dataset schema is unchanged): `de-sn-19408:Artikel#2`, `de-sn-5041:Artikel#7`, `de-sn-5041:Artikel#8`, `de-sn-5041:Artikel#9`, `de-sn-5041:Artikel#10`.
+- Personal data: only personal data of private individuals is redacted (`[REDACTED-<kind>]`); official accounts (Bundesbank / public cash offices), functional and authority mailboxes (e.g. `@sachsen.de`) and table numbers stay verbatim. Redaction markers in the added rows: 0.
+- Pages re-fetched for this rebuild (robots-checked, gated, polite delay) and cached so later parser fixes re-parse offline: 50.
+
+### Known gaps (DE-SN amending acts)
+
+Rows of the added laws that are not in the data (every id with its reason is in `manifests/densify_sn_amending_known_gaps.jsonl`):
+
+- 26 empty `Artikel` headings with no body on the REVOSax page (mostly an Artikel that enacts a separate act, whose text REVOSax keeps under that act's own page): `de-sn-11376:Artikel`, `de-sn-11615:Artikel`, `de-sn-11615:Artikel#2`, `de-sn-11696:Artikel#2`, `de-sn-12339:Artikel#13`, `de-sn-12800:Artikel`, `de-sn-12867:Artikel`, `de-sn-1540:Artikel`, `de-sn-18048:Artikel`, `de-sn-18270:Artikel#3`, `de-sn-18816:Artikel`, `de-sn-1915:Artikel`, `de-sn-19985:Artikel`, `de-sn-20002:Artikel`, `de-sn-20785:Artikel#2`, `de-sn-20785:Artikel#3`, `de-sn-20980:Artikel`, `de-sn-21005:Artikel`, `de-sn-21009:Artikel`, `de-sn-21195:Artikel`, `de-sn-21417:Artikel`, `de-sn-21520:Artikel`, `de-sn-3982:Artikel`, `de-sn-4371:Artikel`, `de-sn-4371:Artikel#2`, `de-sn-5119:Artikel#2`.
+- 2 heading rows with only a footnote number: `de-sn-16702:Artikel#2`, `de-sn-17593:Artikel#2`.
+- 2 attachment stubs (the map / Anhang itself is not on the page): `de-sn-21304:Anlagen`, `de-sn-4976:Anlagen`.
+- 37 trailing heading-only rows (`Anlage`, `Anhang`, `Übersichtskarte` … with no content after them): listed in the manifest.
+
+### source_terms_note
+
+User decision relayed by Chief of Staff on 2026-10-13: 'I want the entire law, the government laws are not copyrighted' (official statute text, § 5 UrhG). Applies to DE-SN (incl. amending acts, VwV), DE-BB VwV, the DE-NW change set, DE-NI (NI-VORIS) and DE-HB (transparenz.bremen.de). Collected robots fail-closed, no WAF/challenge bypass, polite throttling.
+
+Every added row also carries `source_terms_note` inside `metadata_json.metadata`.
+
+DE-SN totals after this batch: 3,976 laws (2,600 + 1,376) / 37,181 articles (33,551 + 3,630). Dataset totals: 12,329 laws / 213,111 articles.
+- The bundled `scrapers/de_lib.py` has default `HUB_TIP` 92488791 (the parent of this batch); set `DE_HUB_TIP` to the current tip before building a new pack.

data/articles.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:ca5e29490f1a2c335767df6125281a991903a55fbe909cefeb010c0a168bc82d
-size 73325075
+oid sha256:02731418eb76b6016ba9a04e94c9f7381798b121a521728a4e511ed42f7e8520
+size 76292125

data/laws.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:f7e428a2a2d853935cf4e8bb1f6ae6d91ae212ea4e157d2a53d4b670ed4cca69
-size 69196884
+oid sha256:c4f907029496f4f85788ca893e0df4537ab34366563d430cc1948e050c4fb984
+size 72370665

manifests/densify_sn_amending_CARD_SECTION.md

@@ -0,0 +1,12 @@
+## DE-SN densify (1376 laws / 3630 articles, append-only at 92488791)
+
+- Source: www.revosax.sachsen.de (revosax); licence: Public domain (gemeinfrei): amtliche Werke i.S.d. § 5 Abs. 1 UrhG; Sächsische Staatskanzlei / revosax.sachsen.de (REVOSax)
+- Kinds: {"amending": 1376}
+- Not added: 2041 records that are duplicates of live rows (1666 id_on_tip, 375 same_title_same_land_on_tip); 2003 stub pages with no norm text of their own (they only point to a parent act)
+- Clean-up (pipeline, added rows only): 0 contents-list rows dropped; revosax footnote HTML converted to plain-text 'Fußnoten:' blocks in 16 article rows and 0 law texts; 18 heading-only rows folded into the next article, 37 trailing ones dropped; 0 titles cleaned; known gaps (dropped, listed in manifests/): 26 empty Artikel headings, 2 footnote-number-only rows, 2 attachment stubs; 5 repeal placeholders kept (metadata_json.body_status)
+
+### source_terms_note
+
+User decision relayed by Chief of Staff on 2026-10-13: 'I want the entire law, the government laws are not copyrighted' (official statute text, § 5 UrhG). Applies to DE-SN (incl. amending acts, VwV), DE-BB VwV, the DE-NW change set, DE-NI (NI-VORIS) and DE-HB (transparenz.bremen.de). Collected robots fail-closed, no WAF/challenge bypass, polite throttling.
+
+Every added row also carries `source_terms_note` inside `metadata_json.metadata`.

manifests/densify_sn_amending_SHA256SUMS

@@ -0,0 +1,34 @@
+9cd03ea60fb0e7bb7c12457a51b2fc1742145e520ce85a9025a25004d06ef528  CARD_SECTION.md
+56ee3c6a557c478e2161cbd541a65214a65544093b7b455438d61664322d105b  DENSIFY_REPORT.json
+5e2e81b2a0c7b9567e3ff2b22f6f7b859aa2b77908ae177473815be698f909af  README.md
+02731418eb76b6016ba9a04e94c9f7381798b121a521728a4e511ed42f7e8520  data/articles.parquet
+c4f907029496f4f85788ca893e0df4537ab34366563d430cc1948e050c4fb984  data/laws.parquet
+623d874fab2d706e01bfe63205a135287ec0bf85d03e381d82466e7a0f0533f1  manifests/densify_sn_amending_added_ids.jsonl
+b9958d06ba879b470ff52f66207dc0d7ee19d6f2cf1526f731c0408dbd4edae8  manifests/densify_sn_amending_known_gaps.jsonl
+eace101b0bc0ed653203b91a45c52ab73befa3a71beddb9c633ee9e1b95da7b5  manifests/densify_sn_amending_not_added.jsonl
+f6f075d3b88033ee06e69ea4bf9c553c64ec24ea3f41175cf4ecbb243bec279d  scrapers/README.md
+03b2ced6ba93f8d387bca7b53e86fb9f8c32619706ec4612a592a44db5682548  scrapers/code.json
+507acbc9b48b84277688ef9f72f2b6f1f79380838bf9baeab923d52a7fb6a3d1  scrapers/collect_de_laender.py
+963ef4d135458eb8e11de9048ac5b1b81249585dbb8c172be9e52941c9958567  scrapers/de_lib.py
+4587e8d9e0b7ce55dffef23d874dae7a03b1093fdead26fd8313d5597c86a31f  scrapers/de_queue.example.txt
+026850a3461008942beb7f5299b3ee58daecf4e7e7e005dcf8baa4e47666a79d  scrapers/de_waiter.sh
+af4465eb44fc84a744176116094436fc01a04d689886cf57da66e5d6347b16ec  scrapers/finalize_gate.py
+315a8fe0768c6d33bb8d3b388508461187959cef48bd4f5aa3630104e95b2f8b  scrapers/fix_contents_titles.py
+2dcc695bebf6ea306c045b13e483097353be8f402e90a8fd3984fa21b3260d1c  scrapers/fix_lawtext_br.py
+048fdd4e5f999ebb49db7491fe9f98c2792a5236cf57f5c7798c260ee927b117  scrapers/fix_sn.py
+fbfbe563bf0b7ceebb8478f8600654dd0f9014c0f3f1a6d467a16230b24a883d  scrapers/gate_profile.sh
+b2f838db772d33a17e51abaedde6adb4e8ac96e4b067761d1a4dc2e0b7db6092  scrapers/pack_de.py
+582f60ecb86fedce8c78fb4cb1b814e8d1ca9b84d72349b4aa9cea7c051dd40f  scrapers/refetch_de.py
+7ec8cb4ff762e625dcf70bb8be15f166ef93cf602ffb234c6c8192a86f5762af  scrapers/refetch_de.sh
+7420dd98db2604b7f2ef9ccbf8679d5aceb9bdd8f769bfca587ae19e15e5be00  scrapers/requirements.txt
+87915efb8db8d5863f7a2d209b27ae4c64bfde7126dd5bf388242b5ed8c3c96b  scrapers/resume_loop_de.sh
+fa8823164631f53174a67a4b100f5278758b151c3e6a522d8c9987bb57753542  scrapers/robots_guard.py
+9b7e5d48f8803a9e6f83e630f03e7110b96f5ea8971adaec771b4c7db50d9798  scrapers/run_de_short.sh
+129c7f34bcacb6ba9bfdd856c68d9b5e33e547107689bde17afa9f61de9e8e09  scrapers/short_turn.sh
+788bd4924861d35f5317b48682712d582190bcfcff3fe9410033b9f8ef5b7418  scrapers/tests/test_de_laender.py
+f63e7554e32afe1e734fe0043271764aaca6899ae4f24f933ed0fe0f6734f49b  scrapers/tests/test_finalize_gate.py
+9811842a3c165c0671d8e150359bba808931088fdf880b43b93adb6b25fb67f6  scrapers/tests/test_fix_contents_titles.py
+994e6a99b74f47d3dc283977cc7021a37c6ff0153da61623d61dd9a96d0817ea  scrapers/tests/test_fix_lawtext_br.py
+6870695e1c3c224c82b1110bb36bcdb0f52be134b98da726456b5e2b483a5264  scrapers/tests/test_fix_sn.py
+6f6681d63f90858cf01924133e07a26d9c56e1f783b7ed35017e513ceb5ce7b7  scrapers/tests/test_short_turn.py
+69fc225e9bdfd05af3c52b5448fe80fae1b91cb98c6bbf409787d47ff4500d79  scrapers/tests/test_sn_rework.py

manifests/densify_sn_amending_code.json

@@ -0,0 +1,30 @@
+{
+ "de_lib.py": "963ef4d135458eb8e11de9048ac5b1b81249585dbb8c172be9e52941c9958567",
+ "collect_de_laender.py": "507acbc9b48b84277688ef9f72f2b6f1f79380838bf9baeab923d52a7fb6a3d1",
+ "pack_de.py": "b2f838db772d33a17e51abaedde6adb4e8ac96e4b067761d1a4dc2e0b7db6092",
+ "robots_guard.py": "fa8823164631f53174a67a4b100f5278758b151c3e6a522d8c9987bb57753542",
+ "run_de_short.sh": "9b7e5d48f8803a9e6f83e630f03e7110b96f5ea8971adaec771b4c7db50d9798",
+ "resume_loop_de.sh": "87915efb8db8d5863f7a2d209b27ae4c64bfde7126dd5bf388242b5ed8c3c96b",
+ "de_waiter.sh": "026850a3461008942beb7f5299b3ee58daecf4e7e7e005dcf8baa4e47666a79d",
+ "gate_profile.sh": "fbfbe563bf0b7ceebb8478f8600654dd0f9014c0f3f1a6d467a16230b24a883d",
+ "de_queue.example.txt": "4587e8d9e0b7ce55dffef23d874dae7a03b1093fdead26fd8313d5597c86a31f",
+ "requirements.txt": "7420dd98db2604b7f2ef9ccbf8679d5aceb9bdd8f769bfca587ae19e15e5be00",
+ "README.md": "f6f075d3b88033ee06e69ea4bf9c553c64ec24ea3f41175cf4ecbb243bec279d",
+ "tests/test_de_laender.py": "788bd4924861d35f5317b48682712d582190bcfcff3fe9410033b9f8ef5b7418",
+ "short_turn.sh": "129c7f34bcacb6ba9bfdd856c68d9b5e33e547107689bde17afa9f61de9e8e09",
+ "tests/test_short_turn.py": "6f6681d63f90858cf01924133e07a26d9c56e1f783b7ed35017e513ceb5ce7b7",
+ "finalize_gate.py": "af4465eb44fc84a744176116094436fc01a04d689886cf57da66e5d6347b16ec",
+ "tests/test_finalize_gate.py": "f63e7554e32afe1e734fe0043271764aaca6899ae4f24f933ed0fe0f6734f49b",
+ "fix_sn.py": "048fdd4e5f999ebb49db7491fe9f98c2792a5236cf57f5c7798c260ee927b117",
+ "tests/test_fix_sn.py": "6870695e1c3c224c82b1110bb36bcdb0f52be134b98da726456b5e2b483a5264",
+ "fix_contents_titles.py": "315a8fe0768c6d33bb8d3b388508461187959cef48bd4f5aa3630104e95b2f8b",
+ "tests/test_fix_contents_titles.py": "9811842a3c165c0671d8e150359bba808931088fdf880b43b93adb6b25fb67f6",
+ "fix_lawtext_br.py": "2dcc695bebf6ea306c045b13e483097353be8f402e90a8fd3984fa21b3260d1c",
+ "tests/test_fix_lawtext_br.py": "994e6a99b74f47d3dc283977cc7021a37c6ff0153da61623d61dd9a96d0817ea",
+ "refetch_de.py": "582f60ecb86fedce8c78fb4cb1b814e8d1ca9b84d72349b4aa9cea7c051dd40f",
+ "refetch_de.sh": "7ec8cb4ff762e625dcf70bb8be15f166ef93cf602ffb234c6c8192a86f5762af",
+ "tests/test_sn_rework.py": "69fc225e9bdfd05af3c52b5448fe80fae1b91cb98c6bbf409787d47ff4500d79",
+ "_notes": {
+  "robots_guard.py": "robots_guard fa882316 (CoS 2026-10-17): adds 'rejected request|support id' to _CHALLENGE and a VERIFY_X509_STRICT-only TLS relax for 4 Taiwan hosts; no German host affected. Earlier DE packs were fetched with 1c9f28bc (one-hop, 2026-10-14)."
+ }
+}

manifests/densify_sn_amending_known_gaps.jsonl

@@ -0,0 +1,72 @@
+{"id": "de-sn-10852:Anlagen", "law_id": "de-sn-10852", "action": "dropped", "reason": "headings_dropped", "why": "trailing heading-only row (no following article to fold into)"}
+{"id": "de-sn-11376:Artikel", "law_id": "de-sn-11376", "action": "dropped", "reason": "norm_headings_dropped", "why": "empty norm heading (Artikel/§ with no body of its own on the revosax page, e.g. an Artikel that enacts a separate act); not merged into the next Artikel"}
+{"id": "de-sn-11615:Artikel", "law_id": "de-sn-11615", "action": "dropped", "reason": "norm_headings_dropped", "why": "empty norm heading (Artikel/§ with no body of its own on the revosax page, e.g. an Artikel that enacts a separate act); not merged into the next Artikel"}
+{"id": "de-sn-11615:Artikel#2", "law_id": "de-sn-11615", "action": "dropped", "reason": "norm_headings_dropped", "why": "empty norm heading (Artikel/§ with no body of its own on the revosax page, e.g. an Artikel that enacts a separate act); not merged into the next Artikel"}
+{"id": "de-sn-11696:Artikel#2", "law_id": "de-sn-11696", "action": "dropped", "reason": "norm_headings_dropped", "why": "empty norm heading (Artikel/§ with no body of its own on the revosax page, e.g. an Artikel that enacts a separate act); not merged into the next Artikel"}
+{"id": "de-sn-12046:Anlagen", "law_id": "de-sn-12046", "action": "dropped", "reason": "headings_dropped", "why": "trailing heading-only row (no following article to fold into)"}
+{"id": "de-sn-12339:Artikel#13", "law_id": "de-sn-12339", "action": "dropped", "reason": "norm_headings_dropped", "why": "empty norm heading (Artikel/§ with no body of its own on the revosax page, e.g. an Artikel that enacts a separate act); not merged into the next Artikel"}
+{"id": "de-sn-12800:Artikel", "law_id": "de-sn-12800", "action": "dropped", "reason": "norm_headings_dropped", "why": "empty norm heading (Artikel/§ with no body of its own on the revosax page, e.g. an Artikel that enacts a separate act); not merged into the next Artikel"}
+{"id": "de-sn-12829:Anhang", "law_id": "de-sn-12829", "action": "dropped", "reason": "headings_dropped", "why": "trailing heading-only row (no following article to fold into)"}
+{"id": "de-sn-12834:Anhang", "law_id": "de-sn-12834", "action": "dropped", "reason": "headings_dropped", "why": "trailing heading-only row (no following article to fold into)"}
+{"id": "de-sn-12867:Artikel", "law_id": "de-sn-12867", "action": "dropped", "reason": "norm_headings_dropped", "why": "empty norm heading (Artikel/§ with no body of its own on the revosax page, e.g. an Artikel that enacts a separate act); not merged into the next Artikel"}
+{"id": "de-sn-12897:Anlagen", "law_id": "de-sn-12897", "action": "dropped", "reason": "headings_dropped", "why": "trailing heading-only row (no following article to fold into)"}
+{"id": "de-sn-13995:Anhang", "law_id": "de-sn-13995", "action": "dropped", "reason": "headings_dropped", "why": "trailing heading-only row (no following article to fold into)"}
+{"id": "de-sn-1540:Artikel", "law_id": "de-sn-1540", "action": "dropped", "reason": "norm_headings_dropped", "why": "empty norm heading (Artikel/§ with no body of its own on the revosax page, e.g. an Artikel that enacts a separate act); not merged into the next Artikel"}
+{"id": "de-sn-16702:Artikel#2", "law_id": "de-sn-16702", "action": "dropped", "reason": "footnote_digit_rows_dropped", "why": "heading plus only a footnote number/marker, no body"}
+{"id": "de-sn-16864:Anhang", "law_id": "de-sn-16864", "action": "dropped", "reason": "headings_dropped", "why": "trailing heading-only row (no following article to fold into)"}
+{"id": "de-sn-17410:Anlage", "law_id": "de-sn-17410", "action": "dropped", "reason": "headings_dropped", "why": "trailing heading-only row (no following article to fold into)"}
+{"id": "de-sn-17573:Anhang", "law_id": "de-sn-17573", "action": "dropped", "reason": "headings_dropped", "why": "trailing heading-only row (no following article to fold into)"}
+{"id": "de-sn-17593:Artikel#2", "law_id": "de-sn-17593", "action": "dropped", "reason": "footnote_digit_rows_dropped", "why": "heading plus only a footnote number/marker, no body"}
+{"id": "de-sn-17845:Anhang", "law_id": "de-sn-17845", "action": "dropped", "reason": "headings_dropped", "why": "trailing heading-only row (no following article to fold into)"}
+{"id": "de-sn-17849:Anlage", "law_id": "de-sn-17849", "action": "dropped", "reason": "headings_dropped", "why": "trailing heading-only row (no following article to fold into)"}
+{"id": "de-sn-17892:Anhang", "law_id": "de-sn-17892", "action": "dropped", "reason": "headings_dropped", "why": "trailing heading-only row (no following article to fold into)"}
+{"id": "de-sn-17924:Anlagen", "law_id": "de-sn-17924", "action": "dropped", "reason": "headings_dropped", "why": "trailing heading-only row (no following article to fold into)"}
+{"id": "de-sn-17985:Anhänge", "law_id": "de-sn-17985", "action": "dropped", "reason": "headings_dropped", "why": "trailing heading-only row (no following article to fold into)"}
+{"id": "de-sn-18048:Artikel", "law_id": "de-sn-18048", "action": "dropped", "reason": "norm_headings_dropped", "why": "empty norm heading (Artikel/§ with no body of its own on the revosax page, e.g. an Artikel that enacts a separate act); not merged into the next Artikel"}
+{"id": "de-sn-18270:Artikel#3", "law_id": "de-sn-18270", "action": "dropped", "reason": "norm_headings_dropped", "why": "empty norm heading (Artikel/§ with no body of its own on the revosax page, e.g. an Artikel that enacts a separate act); not merged into the next Artikel"}
+{"id": "de-sn-18704:Anhang", "law_id": "de-sn-18704", "action": "dropped", "reason": "headings_dropped", "why": "trailing heading-only row (no following article to fold into)"}
+{"id": "de-sn-18740:Anlage", "law_id": "de-sn-18740", "action": "dropped", "reason": "headings_dropped", "why": "trailing heading-only row (no following article to fold into)"}
+{"id": "de-sn-18816:Artikel", "law_id": "de-sn-18816", "action": "dropped", "reason": "norm_headings_dropped", "why": "empty norm heading (Artikel/§ with no body of its own on the revosax page, e.g. an Artikel that enacts a separate act); not merged into the next Artikel"}
+{"id": "de-sn-18905:Anhänge", "law_id": "de-sn-18905", "action": "dropped", "reason": "headings_dropped", "why": "trailing heading-only row (no following article to fold into)"}
+{"id": "de-sn-18922:Anhang", "law_id": "de-sn-18922", "action": "dropped", "reason": "headings_dropped", "why": "trailing heading-only row (no following article to fold into)"}
+{"id": "de-sn-19087:Anhang zu Artikel 1 Nummer 3", "law_id": "de-sn-19087", "action": "dropped", "reason": "headings_dropped", "why": "trailing heading-only row (no following article to fold into)"}
+{"id": "de-sn-1915:Artikel", "law_id": "de-sn-1915", "action": "dropped", "reason": "norm_headings_dropped", "why": "empty norm heading (Artikel/§ with no body of its own on the revosax page, e.g. an Artikel that enacts a separate act); not merged into the next Artikel"}
+{"id": "de-sn-19261:Anhang zu Artikel 1 Nummer 7", "law_id": "de-sn-19261", "action": "dropped", "reason": "headings_dropped", "why": "trailing heading-only row (no following article to fold into)"}
+{"id": "de-sn-19408:Artikel#2", "law_id": "de-sn-19408", "action": "kept", "reason": "repealed_placeholder", "why": "repeal placeholder kept; metadata_json.body_status='repealed_placeholder'; stray footnote digits stripped"}
+{"id": "de-sn-19843:Anlage", "law_id": "de-sn-19843", "action": "dropped", "reason": "headings_dropped", "why": "trailing heading-only row (no following article to fold into)"}
+{"id": "de-sn-19895:Anlage", "law_id": "de-sn-19895", "action": "dropped", "reason": "headings_dropped", "why": "trailing heading-only row (no following article to fold into)"}
+{"id": "de-sn-19985:Artikel", "law_id": "de-sn-19985", "action": "dropped", "reason": "norm_headings_dropped", "why": "empty norm heading (Artikel/§ with no body of its own on the revosax page, e.g. an Artikel that enacts a separate act); not merged into the next Artikel"}
+{"id": "de-sn-20002:Artikel", "law_id": "de-sn-20002", "action": "dropped", "reason": "norm_headings_dropped", "why": "empty norm heading (Artikel/§ with no body of its own on the revosax page, e.g. an Artikel that enacts a separate act); not merged into the next Artikel"}
+{"id": "de-sn-20350:Anhang", "law_id": "de-sn-20350", "action": "dropped", "reason": "headings_dropped", "why": "trailing heading-only row (no following article to fold into)"}
+{"id": "de-sn-20357:Anhang", "law_id": "de-sn-20357", "action": "dropped", "reason": "headings_dropped", "why": "trailing heading-only row (no following article to fold into)"}
+{"id": "de-sn-20769:Anlagen", "law_id": "de-sn-20769", "action": "dropped", "reason": "headings_dropped", "why": "trailing heading-only row (no following article to fold into)"}
+{"id": "de-sn-20785:Artikel#2", "law_id": "de-sn-20785", "action": "dropped", "reason": "norm_headings_dropped", "why": "empty norm heading (Artikel/§ with no body of its own on the revosax page, e.g. an Artikel that enacts a separate act); not merged into the next Artikel"}
+{"id": "de-sn-20785:Artikel#3", "law_id": "de-sn-20785", "action": "dropped", "reason": "norm_headings_dropped", "why": "empty norm heading (Artikel/§ with no body of its own on the revosax page, e.g. an Artikel that enacts a separate act); not merged into the next Artikel"}
+{"id": "de-sn-20980:Artikel", "law_id": "de-sn-20980", "action": "dropped", "reason": "norm_headings_dropped", "why": "empty norm heading (Artikel/§ with no body of its own on the revosax page, e.g. an Artikel that enacts a separate act); not merged into the next Artikel"}
+{"id": "de-sn-21005:Artikel", "law_id": "de-sn-21005", "action": "dropped", "reason": "norm_headings_dropped", "why": "empty norm heading (Artikel/§ with no body of its own on the revosax page, e.g. an Artikel that enacts a separate act); not merged into the next Artikel"}
+{"id": "de-sn-21009:Artikel", "law_id": "de-sn-21009", "action": "dropped", "reason": "norm_headings_dropped", "why": "empty norm heading (Artikel/�� with no body of its own on the revosax page, e.g. an Artikel that enacts a separate act); not merged into the next Artikel"}
+{"id": "de-sn-21083:Anhang zu Nummer 60 und 63", "law_id": "de-sn-21083", "action": "dropped", "reason": "headings_dropped", "why": "trailing heading-only row (no following article to fold into)"}
+{"id": "de-sn-21119:Anhang", "law_id": "de-sn-21119", "action": "dropped", "reason": "headings_dropped", "why": "trailing heading-only row (no following article to fold into)"}
+{"id": "de-sn-21195:Artikel", "law_id": "de-sn-21195", "action": "dropped", "reason": "norm_headings_dropped", "why": "empty norm heading (Artikel/§ with no body of its own on the revosax page, e.g. an Artikel that enacts a separate act); not merged into the next Artikel"}
+{"id": "de-sn-21304:Anlagen", "law_id": "de-sn-21304", "action": "dropped", "reason": "attachment_stubs_dropped", "why": "attachment stub (e.g. 'Anlagen' -> 'Karte'): the attachment itself is not on the page"}
+{"id": "de-sn-21417:Artikel", "law_id": "de-sn-21417", "action": "dropped", "reason": "norm_headings_dropped", "why": "empty norm heading (Artikel/§ with no body of its own on the revosax page, e.g. an Artikel that enacts a separate act); not merged into the next Artikel"}
+{"id": "de-sn-21520:Artikel", "law_id": "de-sn-21520", "action": "dropped", "reason": "norm_headings_dropped", "why": "empty norm heading (Artikel/§ with no body of its own on the revosax page, e.g. an Artikel that enacts a separate act); not merged into the next Artikel"}
+{"id": "de-sn-3982:Artikel", "law_id": "de-sn-3982", "action": "dropped", "reason": "norm_headings_dropped", "why": "empty norm heading (Artikel/§ with no body of its own on the revosax page, e.g. an Artikel that enacts a separate act); not merged into the next Artikel"}
+{"id": "de-sn-4371:Artikel", "law_id": "de-sn-4371", "action": "dropped", "reason": "norm_headings_dropped", "why": "empty norm heading (Artikel/§ with no body of its own on the revosax page, e.g. an Artikel that enacts a separate act); not merged into the next Artikel"}
+{"id": "de-sn-4371:Artikel#2", "law_id": "de-sn-4371", "action": "dropped", "reason": "norm_headings_dropped", "why": "empty norm heading (Artikel/§ with no body of its own on the revosax page, e.g. an Artikel that enacts a separate act); not merged into the next Artikel"}
+{"id": "de-sn-4976:Anlagen", "law_id": "de-sn-4976", "action": "dropped", "reason": "attachment_stubs_dropped", "why": "attachment stub (e.g. 'Anlagen' -> 'Karte'): the attachment itself is not on the page"}
+{"id": "de-sn-5010:Übersichtskarte", "law_id": "de-sn-5010", "action": "dropped", "reason": "headings_dropped", "why": "trailing heading-only row (no following article to fold into)"}
+{"id": "de-sn-5010:Flurkarte 1", "law_id": "de-sn-5010", "action": "dropped", "reason": "headings_dropped", "why": "trailing heading-only row (no following article to fold into)"}
+{"id": "de-sn-5010:Flurkarte 2", "law_id": "de-sn-5010", "action": "dropped", "reason": "headings_dropped", "why": "trailing heading-only row (no following article to fold into)"}
+{"id": "de-sn-5010:Flurkarte 3", "law_id": "de-sn-5010", "action": "dropped", "reason": "headings_dropped", "why": "trailing heading-only row (no following article to fold into)"}
+{"id": "de-sn-5010:Flurkarte 4", "law_id": "de-sn-5010", "action": "dropped", "reason": "headings_dropped", "why": "trailing heading-only row (no following article to fold into)"}
+{"id": "de-sn-5041:Artikel#7", "law_id": "de-sn-5041", "action": "kept", "reason": "repealed_placeholder", "why": "repeal placeholder kept; metadata_json.body_status='repealed_placeholder'; stray footnote digits stripped"}
+{"id": "de-sn-5041:Artikel#8", "law_id": "de-sn-5041", "action": "kept", "reason": "repealed_placeholder", "why": "repeal placeholder kept; metadata_json.body_status='repealed_placeholder'; stray footnote digits stripped"}
+{"id": "de-sn-5041:Artikel#9", "law_id": "de-sn-5041", "action": "kept", "reason": "repealed_placeholder", "why": "repeal placeholder kept; metadata_json.body_status='repealed_placeholder'; stray footnote digits stripped"}
+{"id": "de-sn-5041:Artikel#10", "law_id": "de-sn-5041", "action": "kept", "reason": "repealed_placeholder", "why": "repeal placeholder kept; metadata_json.body_status='repealed_placeholder'; stray footnote digits stripped"}
+{"id": "de-sn-5119:Artikel#2", "law_id": "de-sn-5119", "action": "dropped", "reason": "norm_headings_dropped", "why": "empty norm heading (Artikel/§ with no body of its own on the revosax page, e.g. an Artikel that enacts a separate act); not merged into the next Artikel"}
+{"id": "de-sn-5490:Übersichtskarten  1 bis 5", "law_id": "de-sn-5490", "action": "dropped", "reason": "headings_dropped", "why": "trailing heading-only row (no following article to fold into)"}
+{"id": "de-sn-5623:Übersichtskarte", "law_id": "de-sn-5623", "action": "dropped", "reason": "headings_dropped", "why": "trailing heading-only row (no following article to fold into)"}
+{"id": "de-sn-5624:Übersichtskarte", "law_id": "de-sn-5624", "action": "dropped", "reason": "headings_dropped", "why": "trailing heading-only row (no following article to fold into)"}
+{"id": "de-sn-9571:Anlage", "law_id": "de-sn-9571", "action": "dropped", "reason": "headings_dropped", "why": "trailing heading-only row (no following article to fold into)"}
+{"id": "de-sn-9757:Übersichtskarte", "law_id": "de-sn-9757", "action": "dropped", "reason": "headings_dropped", "why": "trailing heading-only row (no following article to fold into)"}

scrapers/README.md

@@ -48,7 +48,7 @@ export DE_WORK=/workspace/de_laender/work
 .venv/bin/python pack_de.py ids --out $DE_WORK/hub_tip_ids.txt           # public Hub read, no token
 nohup ./de_waiter.sh >/dev/null 2>&1 &                                   # ONE waiter; walks de_queue.txt behind GI, v2 gate, 300 s stagger
 # one slice by hand: .venv/bin/python collect_de_laender.py --land SN --tag amending --kinds amending --existing-ids $DE_WORK/hub_tip_ids.txt
-.venv/bin/python pack_de.py build --land SN --tags -,amending --live-laws tip_laws.parquet --live-articles tip_articles.parquet
+.venv/bin/python pack_de.py build --land SN --tags=-,amending --live-laws tip_laws.parquet --live-articles tip_articles.parquet
 .venv/bin/python pack_de.py build --land NW --tags delta [--include-updates] ...
 DE_HUB_TIP=<current tip> .venv/bin/python pack_de.py stage --land SN    # tip unchanged -> READY_germany_laws_densify_sn
 ```
@@ -100,3 +100,30 @@ leaked into a title after the `Vom <date>` line is cut, and article_count is rec
 - 2026-10-15 23:20 PT: `fix_lawtext_br.py` restores, as line breaks, the `<br>` spots the headings fix had glued in DE-SN law texts
   (exact positions from the pre-fix raw text; re-runs the legacy cleaning and requires a byte-exact match). Its `stage` refuses READY
   until `<out>/HUB_PARENT` holds the live commit of the base pack and the live data shas equal the staged base. Tests `tests/test_fix_lawtext_br.py`.
+
+## DE-SN amending rework (CoS rejection 2026-10-17)
+
+- **PII scan** (`de_lib.pii_scan`) redacts only personal data of private individuals. Kept verbatim: official accounts printed in
+  law (Bundesbank BLZ `xxx00000`, a public payee such as Landeshauptkasse/Staatskasse within 160 chars before, or BIC MARKDEF1),
+  official / functional mailboxes (government domains incl. sub-domains such as `justiz.`, `@sachsen.de`, local parts such as
+  poststelle/datenschutz/spammeldung). The tax-id rule needs a Steuer-ID label within 40 chars on the same line, so table numbers
+  never match. Tests: `tests/test_sn_rework.py`.
+- **SN parser**: tags are removed across lines (attribute-aware), a `>` inside a quoted attribute no longer ends `<section …>`,
+  a section without a title attribute takes its own heading line (never the internal anchor such as `a2`), footnote anchors
+  become `[n]` + `Fußnoten:`. Word breaks lost in one rendering of a heading (title attribute / Eingangsformel h3) are restored
+  from the h4 / h1 / Vollzitat rendering of the same words (`_respace`). Other Länder still use `_text`.
+- **finalize_gate**: raw HTML is any tag-shaped string (generic regex, not a tag list), also escaped `&lt;tag`, comments,
+  attribute residue `">` and footnote attributes, in titles, texts AND every metadata_json string. `heading_only_ids` lists
+  rows with no body beyond their heading; repeal placeholders (`(aufgehoben)`, `weggefallen`, …) are kept and tagged
+  `metadata_json.body_status = "repealed_placeholder"` (metadata, no new column).
+- **clean_record**: an empty `Artikel N` heading is never merged into Artikel N+1 (dropped, listed as a known gap; revosax prints
+  the body of a Mantelgesetz's Artikel as its own /vorschrift page); footnote-digit rows and attachment stubs (`Karte`,
+  `Anhang` with no text) are dropped; other heading-only rows still fold into the next row.
+- **Page cache + re-fetch**: SN/BB/NW/HB pages are cached gzip under `$DE_PAGE_CACHE` (default `/workspace/de_laender/page_cache/<lane>`,
+  outside `$DE_WORK`, so not counted in the tree cap). `refetch_de.sh <LAND> <tag> <ids>` re-fetches only uncached pages under
+  the light gate, the short-lane flock (`flock -n`, never waits holding it), the 300 s stagger and the robots guard; it does not
+  touch the GI/DE turn files. `refetch_de.py reparse` rebuilds records offline from the cache (old record kept once in `records_prev/`).
+  A connection dropped mid-body is `Transient` (one retry, then the id is skipped and reported).
+- **pack_de build** writes `manifests/<prefix>_added_ids.jsonl` (every added law and article id), `_known_gaps.jsonl` and
+  `_not_added.jsonl`, and with `--readme <live README>` a cumulative README (live README + new section); the gate checks the
+  README counts and the manifest against the parquet.

scrapers/code.json

@@ -1,24 +1,30 @@
 {
- "de_lib.py": "410a63b8b89f9cd870711ba76b3bf814e1a3e6d94236939344ef508a17610c90",
- "collect_de_laender.py": "6d3295170bf67bf187bbf361e9e5c9a77fbe5d2fb5c7149bd4b9966e7e479faf",
- "pack_de.py": "a386a7b235b3bf4f1eb0e3df86ef73ef9e3c8688ff7182015df9d730cee79b99",
- "robots_guard.py": "1c9f28bcf6851eaff85180c90bdf8054a3500edca773c5c5a84701e6053f0990",
+ "de_lib.py": "963ef4d135458eb8e11de9048ac5b1b81249585dbb8c172be9e52941c9958567",
+ "collect_de_laender.py": "507acbc9b48b84277688ef9f72f2b6f1f79380838bf9baeab923d52a7fb6a3d1",
+ "pack_de.py": "b2f838db772d33a17e51abaedde6adb4e8ac96e4b067761d1a4dc2e0b7db6092",
+ "robots_guard.py": "fa8823164631f53174a67a4b100f5278758b151c3e6a522d8c9987bb57753542",
  "run_de_short.sh": "9b7e5d48f8803a9e6f83e630f03e7110b96f5ea8971adaec771b4c7db50d9798",
  "resume_loop_de.sh": "87915efb8db8d5863f7a2d209b27ae4c64bfde7126dd5bf388242b5ed8c3c96b",
  "de_waiter.sh": "026850a3461008942beb7f5299b3ee58daecf4e7e7e005dcf8baa4e47666a79d",
  "gate_profile.sh": "fbfbe563bf0b7ceebb8478f8600654dd0f9014c0f3f1a6d467a16230b24a883d",
  "de_queue.example.txt": "4587e8d9e0b7ce55dffef23d874dae7a03b1093fdead26fd8313d5597c86a31f",
  "requirements.txt": "7420dd98db2604b7f2ef9ccbf8679d5aceb9bdd8f769bfca587ae19e15e5be00",
- "README.md": "792bd097762ac6419bda46b832c8aa7846168c42732e7a45191666fd629eb7c3",
+ "README.md": "f6f075d3b88033ee06e69ea4bf9c553c64ec24ea3f41175cf4ecbb243bec279d",
  "tests/test_de_laender.py": "788bd4924861d35f5317b48682712d582190bcfcff3fe9410033b9f8ef5b7418",
  "short_turn.sh": "129c7f34bcacb6ba9bfdd856c68d9b5e33e547107689bde17afa9f61de9e8e09",
  "tests/test_short_turn.py": "6f6681d63f90858cf01924133e07a26d9c56e1f783b7ed35017e513ceb5ce7b7",
- "finalize_gate.py": "09a00eec60380b50e94ef57ec069add4835104bc34082c3981482054af1d12ad",
- "tests/test_finalize_gate.py": "9aec8bddfd4f9f65250e3def710f63097e9e5a2e85fcb4ca1304d0f2e10f8401",
+ "finalize_gate.py": "af4465eb44fc84a744176116094436fc01a04d689886cf57da66e5d6347b16ec",
+ "tests/test_finalize_gate.py": "f63e7554e32afe1e734fe0043271764aaca6899ae4f24f933ed0fe0f6734f49b",
  "fix_sn.py": "048fdd4e5f999ebb49db7491fe9f98c2792a5236cf57f5c7798c260ee927b117",
  "tests/test_fix_sn.py": "6870695e1c3c224c82b1110bb36bcdb0f52be134b98da726456b5e2b483a5264",
  "fix_contents_titles.py": "315a8fe0768c6d33bb8d3b388508461187959cef48bd4f5aa3630104e95b2f8b",
  "tests/test_fix_contents_titles.py": "9811842a3c165c0671d8e150359bba808931088fdf880b43b93adb6b25fb67f6",
  "fix_lawtext_br.py": "2dcc695bebf6ea306c045b13e483097353be8f402e90a8fd3984fa21b3260d1c",
- "tests/test_fix_lawtext_br.py": "994e6a99b74f47d3dc283977cc7021a37c6ff0153da61623d61dd9a96d0817ea"
+ "tests/test_fix_lawtext_br.py": "994e6a99b74f47d3dc283977cc7021a37c6ff0153da61623d61dd9a96d0817ea",
+ "refetch_de.py": "582f60ecb86fedce8c78fb4cb1b814e8d1ca9b84d72349b4aa9cea7c051dd40f",
+ "refetch_de.sh": "7ec8cb4ff762e625dcf70bb8be15f166ef93cf602ffb234c6c8192a86f5762af",
+ "tests/test_sn_rework.py": "69fc225e9bdfd05af3c52b5448fe80fae1b91cb98c6bbf409787d47ff4500d79",
+ "_notes": {
+  "robots_guard.py": "robots_guard fa882316 (CoS 2026-10-17): adds 'rejected request|support id' to _CHALLENGE and a VERIFY_X509_STRICT-only TLS relax for 4 Taiwan hosts; no German host affected. Earlier DE packs were fetched with 1c9f28bc (one-hop, 2026-10-14)."
+ }
 }

scrapers/collect_de_laender.py

@@ -14,12 +14,13 @@ Every request (and every redirect hop, via robots_guard.GuardedSession) is robot
 stops the run. Spacing per host = max(land min_delay, robots Crawl-delay) (BB: 20 s).
 Exit: 0 slice/done, 5 licence flag missing (NI/HB), 2 robots (disallow, or 3rd consecutive robots.txt network failure), 3 land disabled,
 4 memory (<3 GiB for 15 s) / RSS > 1 GiB, 6 host park (401/403/429/challenge -> work/PARKED_host), 143 SIGTERM.
-Output: work/<land>/records/<id>.json  ({"law": row, "articles": [...], "pii_hits": n, "bounds": [...]})
+Output: work/<land>/records/<id>.json  ({"law": row, "articles": [...], "pii_hits": n, "bounds": [...]}); raw pages: $DE_PAGE_CACHE/<land>[_<tag>]/<rid>.html.gz
 """
 import argparse, json, os, re, signal, sys, threading, time
 from pathlib import Path
 
 import requests
+import urllib3
 
 BASE_WORK = Path(os.environ.get("DE_WORK", "/workspace/de_laender/work"))
 os.environ["LEGAL_CORPORA_ROOT"] = os.environ.get("DE_GUARD_ROOT", str(BASE_WORK.parent / "guard_root"))
@@ -28,6 +29,7 @@ sys.path.insert(0, str(HERE))
 import de_lib as L  # noqa: E402
 import robots_guard as RG  # noqa: E402
 
+PAGE_CACHE = Path(os.environ.get("DE_PAGE_CACHE", str(BASE_WORK.parent / "page_cache")))
 SLICE_S = int(os.environ.get("DE_SLICE_SECONDS", "1680"))
 RSS_CAP_MB = 1024
 MAX_ROBOTS_TLS = 3
@@ -123,6 +125,9 @@ class Lane:
         self.state_path = self.work / "state.json"
         self.parked = self.work / "PARKED_host"
         self.req_log = self.work / "requests.jsonl"
+        # gz page cache (added 2026-10-17): re-parse offline after a parser fix instead of re-fetching. Kept OUTSIDE $DE_WORK so
+        # it never counts toward the lane-tree gate cap (300 MB). Default /workspace/de_laender/page_cache/<land>[_<tag>].
+        self.pages = PAGE_CACHE / self.work.name
         self.st = {"queue": {}, "done_ids": [], "ok": 0, "skipped_existing": 0, "bounds_rejects": 0, "pii_hits": 0, "errors": 0,
                    "text_bytes": 0, "requests": 0, "seeded": False, "done": False, "stop_reason": "", "robots_tls_run": 0,
                    "frontier": [], "seen_lists": [], "tip_updates": 0, "kind_filtered": 0}
@@ -156,7 +161,10 @@ class Lane:
                 last = exc; time.sleep(15)
         if r is None:
             raise Transient(str(last))
-        body = r.raw.read(L.BOUNDS["max_page_bytes"] + 1, decode_content=True) or b""
+        try:  # a connection dropped mid-body is transient, not a crash (urllib3 ProtocolError is not a RequestException)
+            body = r.raw.read(L.BOUNDS["max_page_bytes"] + 1, decode_content=True) or b""
+        except (requests.RequestException, urllib3.exceptions.HTTPError, OSError) as exc:
+            r.close(); raise Transient(f"body read failed {url}: {exc}")
         head = body[:6000].decode("utf-8", "replace")
         challenge = bool(CHAL.search(head) and not any(m in head for m in SITE_MARK.get(self.land, ())))
         with self.req_log.open("a") as f:
@@ -173,6 +181,20 @@ class Lane:
         self.st["requests"] += 1; self.st["robots_tls_run"] = 0
         return body.decode(r.encoding or "utf-8", "replace")
 
+    def cache_page(self, rid, page):
+        """Keep the raw fetched page (gzip) so a later parser fix re-parses it offline instead of re-fetching."""
+        import gzip
+        self.pages.mkdir(parents=True, exist_ok=True)
+        tmp = self.pages / f".{rid}.html.gz.tmp"
+        with gzip.open(tmp, "wt", encoding="utf-8") as f:
+            f.write(page)
+        tmp.replace(self.pages / f"{rid}.html.gz")
+
+    def fetch_page(self, s, rid, url, kind="law"):
+        page = self.fetch(s, url, kind)
+        self.cache_page(rid, page)
+        return page
+
     # ------------------------------------------------------------ seeding (resumable frontier of listing pages)
     def _q(self, key, url, kind, **extra):
         if kind not in self.kinds:
@@ -256,13 +278,13 @@ class Lane:
     def item(self, s, rid, v, t0):
         land = self.land
         if land == "SN":
-            info = L.parse_sn_page(self.fetch(s, v["url"], "law"), v["url"])
+            info = L.parse_sn_page(self.fetch_page(s, rid, v["url"]), v["url"])
         elif land == "BB":
-            info = L.parse_bb_page(self.fetch(s, v["url"], "law"), v["url"])
+            info = L.parse_bb_page(self.fetch_page(s, rid, v["url"]), v["url"])
         elif land == "NW":
-            info = L.parse_nw_page(self.fetch(s, v["url"], "law"), v["url"]); info["lastmod"] = v.get("lastmod")
+            info = L.parse_nw_page(self.fetch_page(s, rid, v["url"]), v["url"]); info["lastmod"] = v.get("lastmod")
         elif land == "HB":
-            info = L.parse_hb_page(self.fetch(s, v["url"], "law"), v["url"], rid)
+            info = L.parse_hb_page(self.fetch_page(s, rid, v["url"]), v["url"], rid)
         elif land == "NI":
             part = self.work / "partial" / f"{rid}.json"; part.parent.mkdir(parents=True, exist_ok=True)
             pc = json.loads(part.read_text()) if part.exists() else {"docs": None, "got": {}}

scrapers/de_lib.py

@@ -9,7 +9,7 @@ from urllib.parse import urlsplit
 
 COUNTRY, LANG = "Germany", "de"
 HUB_REPO = "endomorphosis/ipfs_germany_laws"
-HUB_TIP = os.environ.get("DE_HUB_TIP", "f9384361294208adf8ce7f0a7fc2f3eb66cd8434")  # DE-SN headings fix live 2026-10-15 23:05 PT (parent e5474984); set after each upload
+HUB_TIP = os.environ.get("DE_HUB_TIP", "92488791e93016b06d0c26e7dd158ab401c69522")  # SN law-text <br> fix live 2026-10-15 23:22 PT (parent 9c40c341); set after each upload
 
 # Per-Land adapters. enabled=False lands are refused by the collector (no request is ever made).
 LANDS = {
@@ -99,60 +99,254 @@ def de_date(s):
     return f"{int(m.group(3)):04d}-{MONTHS[m.group(2).lower()]:02d}-{int(m.group(1)):02d}"
 
 
+# ---- SN (REVOSax) parser, revised 2026-10-17 after CoS rejected the DE-SN amending densify. Root causes fixed here:
+#  * tags were stripped line by line, so a tag whose attribute value wraps (title="...\n...") survived as raw text
+#    (`<section data-anchor=...>`, `<a href=... title=...>`) -> tags are now removed across lines with an attribute-aware regex;
+#  * `<section\b([^>]*)>` stopped at a '>' inside a quoted attribute (title="...<br>..."), so the section lost its title (title fell
+#    back to the internal anchor, e.g. 'a2') and the rest of the attribute leaked into the text -> attribute-aware open-tag regex;
+#  * title attributes carrying markup (<br>, &lt;br&gt;, soft hyphen) lost the word break -> a line break / tag inside a title is
+#    a space, soft hyphens are dropped;
+#  * revosax itself drops a word break in ONE rendering of a heading: the section title attribute ('Artikel 1
+#    SächsischesWassergesetz (SächsWG)', de-sn-12867) or the Eingangsformel h3 ('zur Änderung derInfektionsschutzgesetz-...',
+#    de-sn-19479), while the h4 / h1 / Vollzitat print the same words with the break -> _respace() unites the word breaks of
+#    renderings that are identical ignoring whitespace; h1/Vollzitat compounds wrapped after a hyphen are re-joined;
+#  * footnote anchors on one line became bare digits ('... Fachschule 1'), split ones raw HTML -> every revosax footnote anchor is
+#    now a '[n]' marker plus a plain-text 'Fußnoten:' block (the format the pipeline already used).
+_TAG_ANY = re.compile(r"""<[A-Za-z!/?](?:[^<>"']|"[^"]*"|'[^']*')*>""")
+_SEC_OPEN = re.compile(r"""<section\b((?:[^>"']|"[^"]*"|'[^']*')*)>""")
+_SN_FN = re.compile(r"""(?is)<a\b((?:[^>"']|"[^"]*"|'[^']*')*)>\s*([^<]{0,12}?)\s*</a\s*>""")
+_NBSP_SHY = re.compile("[\xad\u200b]")
+
+
+def _attr_val(attrs, name):
+    m = re.search(r"""(?is)(?:^|\s)%s\s*=\s*(?:"([^"]*)"|'([^']*)')""" % re.escape(name), attrs or "")
+    return (m.group(1) if m.group(1) is not None else m.group(2)) if m else None
+
+
+def _plain_attr(v):
+    """Attribute text -> one line: entities decoded, markup (<br>, tags) and line breaks become spaces, soft hyphens dropped."""
+    v = html.unescape(v or "")
+    v = re.sub(r"(?i)<br\s*/?>", " ", v)
+    v = _TAG_ANY.sub(" ", v)
+    v = _NBSP_SHY.sub("", v)
+    return re.sub(r"[ \t\r\n]+", " ", v).strip()
+
+
+def _sn_footnotes(fr, notes):
+    """revosax footnote anchors -> ' [n]'; their title attribute is collected into notes {n: text} (document order)."""
+    def rep(m):
+        attrs, label = m.group(1), (m.group(2) or "").strip()
+        href = _attr_val(attrs, "href") or ""; cls = _attr_val(attrs, "class") or ""
+        if "FNID_" not in href and "fussnote" not in cls:
+            return m.group(0)
+        n = (re.search(r"FNID_(\d+)", href) or re.search(r"(\d+)", label) or [None, str(len(notes) + 1)])[1]
+        note = _plain_attr(_attr_val(attrs, "title") or "")
+        if note and n not in notes:
+            notes[n] = note
+        return f" [{n}]"
+    return _SN_FN.sub(rep, fr or "")
+
+
+def _sn_text(fr, notes=None):
+    """HTML fragment -> text lines. Same line-break rules as _text, but tags (incl. ones whose attributes wrap lines) are removed
+    across lines before the split; footnote anchors -> [n] (+ notes)."""
+    own = {} if notes is None else notes
+    fr = _sn_footnotes(fr, own)
+    fr = re.sub(r"""(?is)<(script|style)\b(?:[^>"']|"[^"]*"|'[^']*')*>.*?</\1\s*>""", " ", fr)
+    fr = re.sub(r"(?i)<br\s*/?>|</p\s*>|</dd\s*>|</dt\s*>|</h\d\s*>|</li\s*>|</tr\s*>", "\n", fr)
+    fr = _TAG_ANY.sub(" ", fr)
+    lines = [re.sub(r"[ \t\xa0]+", " ", html.unescape(ln)).strip() for ln in fr.split("\n")]
+    return "\n".join(l for l in lines if l)
+
+
+_WS = re.compile(r"[\s\xa0]")
+
+
+def _hyph_join(t):
+    """'Infektionsschutzgesetz-\nZuständigkeitsverordnung' (a compound wrapped after its hyphen) -> one word."""
+    return re.sub(r"(?<=\w)-[ \t]*\n[ \t]*(?=\w)", "-", t or "")
+
+
+def _respace(primary, *alts):
+    """revosax sometimes drops a word break in one rendering of a heading only (title attribute 'SächsischesWassergesetz', the
+    Eingangsformel h3 'derInfektionsschutzgesetz-...') while another rendering of the SAME words keeps it (the h4 / h1 text).
+    If an alternative has the same characters ignoring whitespace, the word breaks of both are united; the primary's own
+    whitespace characters (e.g. NBSP in 'Artikel\xa01') are kept. Different wording -> primary unchanged."""
+    if not primary:
+        return primary
+    key = _WS.sub("", primary)
+    for alt in alts:
+        if not alt or _WS.sub("", alt) != key or alt == primary:
+            continue
+        out, j = [], 0
+        for ch in primary:
+            if _WS.match(ch):
+                out.append(ch)
+                while j < len(alt) and _WS.match(alt[j]):
+                    j += 1
+                continue
+            if j < len(alt) and _WS.match(alt[j]) and out and not _WS.match(out[-1]):
+                out.append(" ")
+            while j < len(alt) and _WS.match(alt[j]):
+                j += 1
+            out.append(ch); j += 1
+        primary = "".join(out)
+    return primary
+
+
+def _respace_map(before, after, fixes):
+    """Collect the glued words _respace split ('derInfektionsschutzgesetz-...' -> 'der Infektionsschutzgesetz-...')."""
+    if before and after and before != after:
+        for w in before.split():
+            if len(w) > 6:
+                f = _respace(w, _find_span(after, w))
+                if f != w:
+                    fixes[w] = f
+
+
+def _find_span(text, w):
+    """The span of text that equals w ignoring whitespace (None if absent)."""
+    key = _WS.sub("", w)
+    if not key:
+        return None
+    pat = r"[\s\xa0]*".join(re.escape(c) for c in key)
+    m = re.search(pat, text)
+    return m.group(0) if m else None
+
+
+def _apply_fixes(text, fixes):
+    for w, f in fixes.items():
+        text = re.sub(r"(?<!\S)%s(?!\S)" % re.escape(w), f, text)
+    return text
+
+
+def _with_notes(text, notes):
+    return text + ("\n\nFußnoten:\n" + "\n".join(f"[{n}] {t}" for n, t in notes.items()) if notes else "")
+
+
 def parse_sn_page(page, url):
     """REVOSax /vorschrift/<id> page -> title, date, vollzitat, sections."""
     page = page or ""
     m = RE_SN_LAW.match(urlsplit(url).path)
     rid = m.group(1) if m else ""
     h1 = re.search(r"<h1[^>]*>(.*?)</h1>", page, re.S)
-    short = _text(h1.group(1)) if h1 else ""
+    short = _plain_attr(_hyph_join(_sn_text(h1.group(1))).replace("\n", " ")) if h1 else ""
     vz = re.search(r"<p>\s*Vollzitat:(.*?)</p>", page, re.S)
-    vollzitat = _text(vz.group(1)) if vz else ""
-    head = re.search(r'<header[^>]*title="Eingangsformel"[^>]*>(.*?)</header>', page, re.S)
-    long_title = _text(re.sub(r"(?s)<p.*", "", head.group(1))).replace("\n", " ") if head else ""
+    vollzitat = _hyph_join(_sn_text(vz.group(1))) if vz else ""
+    head = re.search(r"""<header\b(?:[^>"']|"[^"]*"|'[^']*')*title="Eingangsformel"(?:[^>"']|"[^"]*"|'[^']*')*>(.*?)</header>""", page, re.S)
+    long_title, fixes = "", {}
+    if head:
+        ht = re.sub(r"(?s)<p\b.*", "", head.group(1))
+        ht = re.sub(r"""(?is)<a\b(?:[^>"']|"[^"]*"|'[^']*')*(?:fussnote|FNID_)(?:[^>"']|"[^"]*"|'[^']*')*>.*?</a\s*>""", " ", ht)  # no footnotes in titles
+        long_title = _NBSP_SHY.sub("", _sn_text(ht)).replace("\n", " ")
+        long_title = re.sub(r" {2,}", " ", long_title).strip()
+        raw_long = long_title
+        long_title = _respace(long_title, short, re.sub(r"\s+vom\s.*$", "", vollzitat.replace("\n", " ")))
+        _respace_map(raw_long, long_title, fixes)
     vom = re.search(r"<b>\s*Vom\s+([^<]+)</b>", head.group(1)) if head else None
     date = de_date(vom.group(1)) if vom else de_date(vollzitat)
     art = re.search(r'<article[^>]*id="lesetext"[^>]*>(.*?)</article>', page, re.S)
     body = art.group(1) if art else ""
     secs = []
-    opens = list(re.finditer(r'<section\b([^>]*)>', body))
+    opens = list(_SEC_OPEN.finditer(body))
     for k, sm in enumerate(opens):  # nested sections: each section's own text runs to the next <section> opening
         attrs = sm.group(1)
         inner = body[sm.end(): opens[k + 1].start() if k + 1 < len(opens) else len(body)]
-        t = re.search(r'title="([^"]*)"', attrs)
-        a = re.search(r'id="([^"]*)"', attrs)
-        txt = _text(inner)
+        t = _attr_val(attrs, "title"); a = _attr_val(attrs, "id")
+        notes = {}
+        txt = _sn_text(inner, notes)
         if txt:
-            secs.append({"anchor": a.group(1) if a else str(len(secs) + 1), "title": html.unescape(t.group(1)) if t else "", "text": txt})
-    full = _text(body)
+            title = _plain_attr(t) if t is not None else ""
+            h = re.search(r"(?is)<h\d\b[^>]*>(.*?)</h\d\s*>", inner)
+            if title and h:  # the section heading as printed keeps word breaks the title attribute can lose
+                raw_t = title
+                title = _respace(title, _plain_attr(_sn_text(h.group(1)).replace("\n", " ")))
+                _respace_map(raw_t, title, fixes)
+            if not title:  # no title attribute: the section's own heading line, never the internal anchor
+                first = txt.split("\n", 1)[0]
+                title = first if RE_ENBEZ.match(first) and len(first) <= 120 else ""
+            secs.append({"anchor": a if a else str(len(secs) + 1), "title": title, "text": _with_notes(txt, notes)})
+    allnotes = {}
+    full = _with_notes(_sn_text(body, allnotes), allnotes)
+    if fixes:  # the same glued words in the printed text (Eingangsformel, Inhaltsübersicht)
+        full = _apply_fixes(full, fixes)
+        for sec in secs:
+            sec["text"] = _apply_fixes(sec["text"], fixes)
     return {"revosax_id": rid, "short_title": short, "title": long_title or short, "vollzitat": vollzitat, "date": date,
             "sections": secs, "text": full}
 
 
 # ---------------------------------------------------------------- PII scan (gazette texts normally carry none)
-RE_EMAIL = re.compile(r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b")
-RE_IBAN = re.compile(r"\bDE\d{2}(?:\s?\d{4}){4}\s?\d{2}\b")
-RE_STEUER = re.compile(r"\b\d{2}\s?\d{3}\s?\d{3}\s?\d{3}\b")  # 11-digit Steuer-IdNr shape
-OFFICIAL_MAIL = re.compile(r"@(?:[a-z0-9-]+\.)*(?:sachsen|brandenburg|nrw|niedersachsen|bremen|bund|de\.eu)\.de$|@[a-z0-9.-]*\.(?:gov|europa\.eu)$", re.I)
+# Revised 2026-10-17 after CoS rejected the DE-SN amending densify (76 over-redactions: 60 table numbers taken for tax ids,
+# 12 official treasury IBANs printed in the law, 4 official mailboxes). Only personal data of PRIVATE individuals is redacted:
+#  - e-mail: kept when the domain is an authority / public-body domain (soft hyphens and line-wrap tolerated) or the local part is a
+#    functional mailbox (poststelle@, datenschutz@, info@ ...); otherwise redacted.
+#  - IBAN: kept when it is an official account: Deutsche Bundesbank bank code (BLZ xxx000 00 / BIC MARKDEF1xxx) or a public payee
+#    (Bundes-/Landes-/Staats-/Gerichtskasse, Finanzamt, Fonds, Freistaat ...) within 160 chars before it; otherwise redacted.
+#  - Steuer-IdNr: only an 11-digit number on ONE line, introduced by a tax-id label (Steuer-ID, Steuer-Identifikationsnummer,
+#    IdNr ...) within 40 chars; bare digit runs (tables, amounts, Aktenzeichen) never fire.
+_SHY = "\xad\u200b"
+RE_EMAIL = re.compile(r"(?<![\w.%+-])[A-Za-z0-9._%+-]+@(?:[A-Za-z0-9-]+[" + _SHY + r"]*\.[" + _SHY + r"]*)+[A-Za-z]{2,}\b")
+RE_IBAN = re.compile(r"\bDE ?\d{2}(?:[ \xa0]?\d{4}){4}[ \xa0]?\d{2}\b")
+RE_STEUER = re.compile(r"(?i)(?:steuer[- ]?(?:id|identifikations)(?:[- ]?(?:nr|nummer))?\.?|\bidnr\.?|identifikationsnummer(?: nach § 139b AO)?)"
+                       r"[ \t:.\xa0-]{0,40}?(\d{2}[ \xa0]?\d{3}[ \xa0]?\d{3}[ \xa0]?\d{3})(?![\d])")
+OFFICIAL_MAIL = re.compile(r"@(?:[a-z0-9-]+\.)*(?:sachsen|brandenburg|nrw|niedersachsen|bremen|bund|berlin|hamburg|hessen|bayern|saarland|"
+                           r"thueringen|sachsen-anhalt|schleswig-holstein|rlp|mv-regierung|landtag[a-z-]*|bundesbank|bsi|bfdi)\.de$|"
+                           r"@[a-z0-9.-]*\.(?:gov|europa\.eu|gv\.at|admin\.ch)$|@(?:[a-z0-9-]+\.)*(?:landkreis|kreis|stadt|gemeinde)[a-z0-9-]*\.de$", re.I)
+FUNCTIONAL_LOCAL = re.compile(r"^(?:poststelle|post|info|kontakt|datenschutz|datenschutzbeauftragte[rn]?|dsb|presse|service|buergerservice|"
+                              r"verwaltung|sekretariat|zentrale|vergabe|beschwerde[n]?|phishing|spam|[a-z]*meldung(?:en)?|abuse|cert|security|sicherheit|it-sicherheit|"
+                              r"poststelle\.[a-z0-9-]+|[a-z]+stelle|office|mail|webmaster|redaktion|kanzlei|geschaeftsstelle|einreichung|antrag|"
+                              r"[a-z0-9-]*(?:referat|abteilung|amt|stelle|behoerde|ministerium|portal|team|service|support)[a-z0-9.-]*)$", re.I)
+OFFICIAL_PAYEE = re.compile(r"(?i)bundeskasse|landeskasse|landeshauptkasse|staatskasse|gerichtskasse|justizkasse|amtskasse|zahlstelle|"
+                            r"finanzamt|bundesbank|freistaat|landesamt|bundesamt|staatsministerium|ministerium|fonds|sondervermögen|"
+                            r"anstalt des öffentlichen rechts|körperschaft|landesdirektion|regierungspräsidium|kommunal|stadtkasse|kreiskasse")
+RE_BIC_BBK = re.compile(r"(?i)\bMARK\s?DE\s?F\s?1")
+
+
+# a public body's own sub-domain anywhere in the host (also when the printed TLD part has a typo, e.g. the official
+# 'spammeldung@lit.justiz.sachsden.de' in de-sn-20360)
+OFFICIAL_HOST_LABEL = re.compile(r"(?i)@(?:[a-z0-9-]+\.)*(?:justiz|polizei|landtag|bundestag|gericht|[a-z-]*gericht|staatsanwaltschaft|"
+                                 r"finanzamt|finanzverwaltung|landesamt|bundesamt|ministerium|[a-z]*ministerium|staatskanzlei|"
+                                 r"landesdirektion|regierungspraesidium|bezirksregierung|kreis|landkreis|stadt|gemeinde)\.")
+
+
+def _mail_plain(m):
+    return re.sub("[" + _SHY + "]", "", m)
+
+
+def mail_is_official(addr):
+    a = _mail_plain(addr)
+    return bool(OFFICIAL_MAIL.search(a) or OFFICIAL_HOST_LABEL.search(a)) or bool(FUNCTIONAL_LOCAL.match(a.split("@", 1)[0]))
+
+
+def iban_is_official(iban, before, after=""):
+    digits = re.sub(r"\D", "", iban)  # kk + BLZ(8) + account(10)
+    blz = digits[2:10]
+    if len(blz) == 8 and blz[3:] == "00000":  # Deutsche Bundesbank branch (BLZ xxx000 00): accounts of public bodies only
+        return True
+    return bool(OFFICIAL_PAYEE.search(before[-160:])) or bool(RE_BIC_BBK.search(after[:40]))
 
 
 def pii_scan(text):
-    """Return (redacted_text, hits). Official authority mailboxes are kept; private mails, IBANs, phone-like
-    numbers outside citation context and Steuer-IdNr shapes are redacted to [REDACTED-<kind>]."""
+    """Return (redacted_text, hits). Redacts only personal data of private individuals (see the rules above); official
+    accounts and functional / authority mailboxes stay verbatim. hits = [(kind, value)] of the redactions made."""
     hits = []
+    src = text or ""
 
     def mail(m):
-        if OFFICIAL_MAIL.search(m.group(0)):
+        if mail_is_official(m.group(0)):
             return m.group(0)
         hits.append(("email", m.group(0))); return "[REDACTED-email]"
-    t = RE_EMAIL.sub(mail, text or "")
+    t = RE_EMAIL.sub(mail, src)
 
     def iban(m):
+        if iban_is_official(m.group(0), m.string[:m.start()], m.string[m.end():]):
+            return m.group(0)
         hits.append(("iban", m.group(0))); return "[REDACTED-iban]"
     t = RE_IBAN.sub(iban, t)
 
     def steuer(m):
-        hits.append(("taxid", m.group(0))); return "[REDACTED-taxid]"
+        hits.append(("taxid", m.group(1))); return m.group(0)[:m.start(1) - m.start(0)] + "[REDACTED-taxid]"
     t = RE_STEUER.sub(steuer, t)
     return t, hits
 
@@ -480,9 +674,14 @@ def ni_assemble(node_label, docs):
 
 # ---- record clean-up (2026-10-15, after CoS rejected the DE-SN densify): applied to every collected record at pack time,
 # so it holds for every future Land pack. Live tip rows are never touched (append-only).
-from finalize_gate import strip_html_footnotes, strip_html_title, is_contents_row, fold_heading_rows  # noqa: E402
+from finalize_gate import (strip_html_footnotes, strip_html_title, is_contents_row, fold_heading_rows, is_heading_only,  # noqa: E402
+                           is_bodyless, is_repeal_placeholder, has_raw_html, RAW_HTML)
 
 _TITLE_BODY = re.compile(r"(\sVom \d{1,2}\.\s*\S+\s+\d{4})\s+(\S.{20,})$", re.S)
+# norm headings (2026-10-17): an empty 'Artikel N' / '§ N' row is never merged into the next Artikel (CoS); see clean_record.
+NORM_HEAD = re.compile(r"^\s*(?:Artikel|Art\.|§§?)\s*\d", re.I)
+ATTACH_TITLE = re.compile(r"^\s*(?:Anlagen?|Anh[aä]nge?|Anlage\s*\d+[a-z]?|Anhang\s*\d+[a-z]?)\s*$", re.I)
+ATTACH_STUB = re.compile(r"^\s*(?:Karten?|Übersichtskarten?|Anhang|Anh[aä]nge|Anlagen?|Plan|Pläne|Lageplan|Flurkarte|Abbildung(?:en)?|Tabelle(?:n)?|Muster|Formular)\s*\d*\s*$", re.I)
 
 
 def clean_title(t):
@@ -492,11 +691,72 @@ def clean_title(t):
     return t[:m.end(1)].strip() if m else t
 
 
+def _clean_meta(mj):
+    """Strip HTML out of every string in a metadata_json document (e.g. a revosax <a ... data-name=...> left in `titel`)."""
+    if not mj or ("<" not in mj and "&lt;" not in mj):
+        return mj, False
+    try:
+        d = json.loads(mj)
+    except ValueError:
+        return mj, False
+    hit = [False]
+
+    def walk(v):
+        if isinstance(v, str):
+            if RAW_HTML.search(v):
+                hit[0] = True
+                return strip_html_title(v)
+            return v
+        if isinstance(v, dict):
+            return {k: walk(x) for k, x in v.items()}
+        if isinstance(v, list):
+            return [walk(x) for x in v]
+        return v
+    d = walk(d)
+    return (json.dumps(d, ensure_ascii=False), True) if hit[0] else (mj, False)
+
+
+def repeal_placeholder_row(a):
+    """'Artikel 7\n1\n(außer Kraft)' / 'Artikel 2\n(aufgehoben) 1' / '... [1] ... Fußnoten:' -> stray footnote digits and markers
+    stripped from the text; the footnote note (if any) is kept in metadata_json.footnotes; metadata_json.body_status =
+    'repealed_placeholder' (the live schema has no body_status column)."""
+    text = a.get("text") or ""
+    notes = ""
+    m = re.search(r"\n\s*Fußnoten:\s*\n(.*)\Z", text, re.S)
+    if m:
+        notes, text = m.group(1).strip(), text[:m.start()]
+    text = re.sub(r"\s*\[\d{1,3}\]", "", text)
+    lines = [ln.strip() for ln in text.split("\n") if ln.strip()]
+    out = []
+    for k, ln in enumerate(lines):
+        if k and re.fullmatch(r"\d{1,3}", ln):
+            continue  # superscript footnote number on its own line
+        if k:
+            ln = re.sub(r"(\))\s+\d{1,3}$", r"\1", ln)  # '(aufgehoben) 1'
+        out.append(ln)
+    try:
+        md = json.loads(a.get("metadata_json") or "{}")
+    except ValueError:
+        md = {}
+    md["body_status"] = "repealed_placeholder"
+    if notes:
+        md["footnotes"] = notes
+    return dict(a, text="\n".join(out), metadata_json=json.dumps(md, ensure_ascii=False))
+
+
 def clean_record(rec):
-    """Returns (rec, stats). Strips raw footnote HTML (-> '[n]' + plain 'Fußnoten:' block), drops contents-list rows,
-    folds heading-only rows into the next article, trims body text out of titles, recomputes article_count."""
+    """Returns (rec, stats). Strips raw HTML (footnote anchors -> '[n]' + plain 'Fußnoten:' block; any other tag; HTML inside
+    metadata_json strings), drops contents-list rows, trims body text out of titles, recomputes article_count, and (2026-10-17):
+      * repeal placeholders ('Artikel 7 (aufgehoben)') are KEPT, tagged metadata_json.body_status='repealed_placeholder', stray
+        footnote digits stripped;
+      * an empty norm heading ('Artikel N' / '§ N' with no body, incl. heading + footnote digits only) is never merged into the next
+        Artikel: it is folded only when the next row is not itself a norm heading row (Artikel -> its § rows), otherwise dropped
+        (known gap, listed);
+      * rows with a heading plus only footnote markers/digits are dropped; attachment stubs ('Anlagen' -> 'Karte') are dropped;
+      * other heading-only rows (Teil/Abschnitt/Zustimmungsgesetz ...) fold into the next article as before; trailing ones drop."""
     st = {"footnote_rows": 0, "footnote_law_texts": 0, "contents_dropped": [], "headings_folded": 0, "headings_dropped": [],
-          "titles_trimmed": []}
+          "titles_trimmed": [], "norm_headings_dropped": [], "footnote_digit_rows_dropped": [], "attachment_stubs_dropped": [],
+          "repealed_placeholders": [], "metadata_html_cleaned": 0, "folded_ids": []}
     law = dict(rec["law"])
     t, n = strip_html_footnotes(law.get("text") or "")
     if n or t != (law.get("text") or ""):
@@ -504,6 +764,8 @@ def clean_record(rec):
     nt = clean_title(law.get("title"))
     if nt != law.get("title"):
         st["titles_trimmed"].append(law["id"]); law["title"] = nt
+    law["metadata_json"], hit = _clean_meta(law.get("metadata_json"))
+    st["metadata_html_cleaned"] += int(hit)
     arts = []
     for a in rec.get("articles", []):
         a = dict(a)
@@ -512,10 +774,45 @@ def clean_record(rec):
         if tx != (a.get("text") or "") or ti != (a.get("title") or ""):
             st["footnote_rows"] += 1
         a["text"], a["title"] = tx, ti
+        a["metadata_json"], hit = _clean_meta(a.get("metadata_json"))
+        st["metadata_html_cleaned"] += int(hit)
         if is_contents_row(ti):
             st["contents_dropped"].append(a["id"]); continue
         arts.append(a)
-    arts, folded, dropped = fold_heading_rows(arts)
-    st["headings_folded"], st["headings_dropped"] = len(folded), dropped
-    law["article_count"] = len(arts)
-    return dict(rec, law=law, articles=arts), st
+    # classify and fold (one pass)
+    out, carry = [], []
+    for k, a in enumerate(arts):
+        ti, tx = a["title"], a["text"]
+        if is_repeal_placeholder(ti, tx):
+            a = repeal_placeholder_row(a); st["repealed_placeholders"].append(a["id"])
+        elif is_bodyless(ti, tx):
+            if NORM_HEAD.match(ti):
+                nxt = arts[k + 1] if k + 1 < len(arts) else None
+                if nxt is not None and not (NORM_HEAD.match(nxt["title"]) and _norm_kind(nxt["title"]) == _norm_kind(ti)):
+                    carry.append(a); continue  # 'Artikel 3' heading over the § rows of the act it contains
+                (st["footnote_digit_rows_dropped"] if _fn_residue(ti, tx) else st["norm_headings_dropped"]).append(a["id"]); continue
+            if _fn_residue(ti, tx) and not is_heading_only(ti, tx):
+                st["footnote_digit_rows_dropped"].append(a["id"]); continue
+            carry.append(a); continue
+        elif ATTACH_TITLE.match(ti) and ATTACH_STUB.match(tx or ""):
+            st["attachment_stubs_dropped"].append(a["id"]); continue
+        if carry:
+            a = dict(a, text="\n".join(c["title"].strip() for c in carry) + "\n" + (a.get("text") or ""))
+            st["folded_ids"] += [c["id"] for c in carry]; carry = []
+        out.append(a)
+    st["headings_dropped"] = [c["id"] for c in carry]
+    st["headings_folded"] = len(st["folded_ids"])
+    law["article_count"] = len(out)
+    return dict(rec, law=law, articles=out), st
+
+
+def _fn_residue(ti, tx):
+    """The text carries footnote markers / a footnote block / standalone digits that are not in the heading."""
+    if re.search(r"\[\d{1,3}\]|\nFußnoten:", tx or ""):
+        return True
+    d = lambda x: sorted(re.findall(r"(?<![\w.])\d{1,3}(?![\w.])", re.sub(r"\s+", " ", x or "")))  # noqa: E731
+    return d(tx) != d(ti)
+
+
+def _norm_kind(t):
+    return "art" if re.match(r"^\s*(?:Artikel|Art\.)", t or "", re.I) else "par"

scrapers/finalize_gate.py

@@ -3,7 +3,8 @@
 Added 2026-10-15 after CoS rejected the DE-SN densify HUB-READY (contents-list rows, raw revosax footnote HTML, card kind
 counts taken before drops). Four checks (4th added 2026-10-15 22:50 PT), each must be 0 / True before a pack may be staged:
   1. contents_rows      article rows that are a table of contents (title is a contents heading)
-  2. raw_html_rows      law/article texts or titles still carrying HTML markup (tags, href/class attributes, FNID anchors)
+  2. raw_html_rows      law/article titles, texts or metadata_json strings still carrying HTML markup: ANY tag (generic regex,
+                        2026-10-17), escaped tags, attribute residue, FNID anchors
   3. card_matches_data  every count printed on the card equals the count recomputed from the written parquet
   4. heading_only_ok    heading-only rows (text == title, whitespace collapsed: 'Teil 1\nX' == 'Teil 1 X') == the number the
                         card discloses as kept (0 for DE, where they are folded into the next article)
@@ -15,11 +16,28 @@ CONTENTS_TITLE = re.compile(
     r"^\s*(?:inhaltsverzeichnis|inhaltsübersicht|inhaltsuebersicht|table of contents|contents|arrangement of (?:sections|regulations|rules|clauses)|"
     r"indholdsfortegnelse|innehållsförteckning|innihaldsyvirlit)\s*(?:\[\d+\]|\d+)?\s*[:.]?\s*$", re.I)
 HTML_TAGS = r"(?:a|abbr|b|br|dd|div|dl|dt|em|font|h[1-6]|i|img|li|ol|p|span|strong|sub|sup|table|tbody|td|th|thead|tr|u|ul)"
-RAW_HTML = re.compile(r"(?is)</?%s\b[^>]*>|<a\s+(?:title|class|href)=|\bclass=\"fussnote_link\"|href=\"#FNID_\d+\"|\bfussnote_link\b" % HTML_TAGS)
+# Generic raw-HTML detector (2026-10-17, after `<section data-anchor=...>` tags passed the old tag list): ANY tag name, not a list.
+#  - a tag with attribute syntax, any case, closed or cut off:   <section data-anchor="1" ...>   <a href="/x" title="..."   <A HREF=x>
+#  - a bare open/close/void tag whose name is all-lowercase or all-uppercase: <p> </div> <br/> <BR> <wbr> <o:p>
+#  - escaped markup (&lt;section ...&gt;), comments/doctype, and attribute residue of a broken tag ('...)">').
+#  Statute placeholders such as <ER/SIE>, <Name>, <Ort> and comparisons like "a < b > c" are not markup and do not match.
+_ATTR = r"""[A-Za-z_:][-\w:.]*\s*=\s*(?:"[^"]*"?|'[^']*'?|[^\s"'<>=`]+)"""
+RAW_HTML = re.compile(
+    r"<[A-Za-z][-\w:]*\s+" + _ATTR +                                     # tag with attributes (closed or not)
+    r"|</?(?:[a-z][a-z0-9]*(?:[:-][a-z0-9]+)*|[A-Z][A-Z0-9]*)\s*/?>"         # bare tag, one-case name
+    r"|&lt;/?[A-Za-z][-\w:]*(?:\s|/?&gt;)"                                  # escaped tag
+    r"|<!--|<!DOCTYPE|<!\[CDATA\["                                            # comment / doctype / cdata
+    r'|"\s*/?>'                                                              # residue of a cut-off attribute value
+    r"|\bclass=\"fussnote_link\"|href=\"#FNID_\d+\"|\bfussnote_link\b|\bdata-(?:anchor|level|link|name|id)=")
 _FN_ANCHOR = re.compile(r"(?is)<a\b([^>]*)>[ \t]*(\d{1,3}(?:[ \t]+\d{1,3})*(?=\s*(?:<|$))|\d{1,3}|[^<\d]{0,12}?(?=\s*</a))?(?:\s*</a\s*>)?")
 _FN_TRUNC = re.compile(r"(?is)<a\b[^>]*$")  # anchor cut off at the end of a split article
 _BR = re.compile(r"(?i)<br\s*/?>")
-_TAG = re.compile(r"(?is)</?%s\b[^>]*>" % HTML_TAGS)
+_TAG_LIST = re.compile(r"(?is)</?%s\b[^>]*>" % HTML_TAGS)
+# any real tag (2026-10-17): a tag with attribute syntax (any name, attribute values may wrap lines), or a bare tag with a one-case
+# name. '<ER/SIE>', '<Name>', 'a < b > c' are statute text and stay.
+_ATTR_STRICT = r"""[A-Za-z_:][-\w:.]*(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s"'<>=`]+))?"""
+_ATTR_EQ = r"""[A-Za-z_:][-\w:.]*\s*=\s*(?:"[^"]*"|'[^']*'|[^\s"'<>=`]+)"""
+_TAG = re.compile(r"<[A-Za-z][-\w:]*(?:\s+" + _ATTR_STRICT + r")*?\s+" + _ATTR_EQ + r"(?:\s+" + _ATTR_STRICT + r")*\s*/?>|</?(?:[a-z][a-z0-9]*(?:[:-][a-z0-9]+)*|[A-Z][A-Z0-9]*)\s*/?>")
 
 
 def ws(s):
@@ -27,11 +45,45 @@ def ws(s):
     return re.sub(r"\s+", " ", s or "").strip()
 
 
+_FN_BLOCK = re.compile(r"\n\s*Fußnoten:\s*\n.*\Z", re.S)
+_FN_MARK = re.compile(r"\s*\[\d{1,3}\]")
+REPEAL = re.compile(r"^\(?\s*(?:aufgehoben|weggefallen|außer\s+kraft|ausser\s+kraft|gestrichen|entfallen|nicht\s+mehr\s+belegt)\s*\)?\.?$", re.I)
+
+
 def is_heading_only(title, text):
     t = ws(text)
     return bool(t) and t == ws(title)
 
 
+def body_text(title, text):
+    """What the row says beyond its own heading: the footnote block and [n] markers are removed, standalone 1-3 digit words
+    (superscript footnote numbers such as 'Artikel 7\n1\n(außer Kraft)' or '... Fachschule 1') are ignored on both sides, and the
+    heading (title) words are removed from the start. '' = the row carries no body of its own."""
+    def toks(x):
+        return [w for w in ws(_FN_MARK.sub(" ", x or "")).split(" ") if w and not re.fullmatch(r"\d{1,3}", w)]
+    tt = toks(_FN_BLOCK.sub("", text or "")); hh = toks(title)
+    if hh and tt[:len(hh)] == hh:
+        return " ".join(tt[len(hh):])
+    j = lambda x: re.sub(r"[\W_]+", "", "".join(x))  # noqa: E731  letters/digits only: wrap, spacing, line-end hyphen, '( X )' vs '(X'
+    if hh and j(tt) and j(tt) == j(hh):  # same heading as the title, only punctuation/spacing differs
+        return ""
+    return " ".join(tt)
+
+
+def is_bodyless(title, text):
+    """Heading-only in the wider sense: nothing but the heading, footnote markers/digits and a footnote block."""
+    return bool(ws(text)) and body_text(title, text) == ""
+
+
+def is_repeal_placeholder(title, text):
+    """'Artikel 7 (aufgehoben)' / '(außer Kraft)' / '(weggefallen)' rows: the heading itself says the norm is repealed."""
+    h = ws(_FN_MARK.sub("", title or ""))
+    m = re.search(r"\(([^()]*)\)\s*$", h)
+    tail = m.group(0) if m else ""
+    b = body_text(title, text)
+    return bool(tail and REPEAL.match(tail)) and (b == "" or bool(REPEAL.match(b)))
+
+
 def _attr(attrs, name):
     m = re.search(r'(?is)\b%s\s*=\s*"([^"]*)"' % name, attrs)
     return m.group(1) if m else ""
@@ -40,7 +92,7 @@ def _attr(attrs, name):
 def strip_html_footnotes(text):
     """revosax-style '<a title="NOTE" class="fussnote_link" href="#FNID_n"> n</a>' -> inline '[n]' plus a plain-text
     'Fußnoten:' block at the end; any other known HTML tag is removed. Returns (clean_text, n_footnotes_converted)."""
-    if not text or "<" not in text:
+    if not text or ("<" not in text and "&lt;" not in text):
         return text, 0
     notes, order = {}, []
 
@@ -60,7 +112,9 @@ def strip_html_footnotes(text):
         if note:
             mm = re.search(r"FNID_(\d+)", m.group(0)); n = mm.group(1) if mm else str(len(order) + 1); notes[n] = note; order.append(n); out += f" [{n}]"
     out = _BR.sub("\n", out)  # a line break separates words: never glue them (fixed 2026-10-15 after 'elektronischenInformations-')
-    out = _TAG.sub("", out)
+    out = _TAG_LIST.sub("", out)
+    out = _TAG.sub("\x00", out)  # any other tag (e.g. <section data-anchor=...>): a space, never glue words;
+    out = re.sub(r"(?m)^[ \t\x00]*\x00[ \t\x00]*\n", "", out).replace("\x00", " ")  # a line that held only a tag goes away
     out = re.sub(r"[ \t]+\n", "\n", re.sub(r"[ \t]{2,}", " ", out)).strip()
     if order:
         out += "\n\nFußnoten:\n" + "\n".join(f"[{n}] {notes[n]}" for n in order)
@@ -95,21 +149,64 @@ def fold_heading_rows(articles):
     return out, folded, dropped
 
 
-def gate(law_rows, article_rows, card_counts, data_counts, heading_only_allowed=0):
+def _strings(v):
+    if isinstance(v, str):
+        yield v
+    elif isinstance(v, dict):
+        for x in v.values():
+            yield from _strings(x)
+    elif isinstance(v, list):
+        for x in v:
+            yield from _strings(x)
+
+
+def row_strings(row):
+    """Every text-bearing field of a row: title, text and each string inside metadata_json (decoded; raw string if not JSON)."""
+    import json
+    out = [row.get("title") or "", row.get("text") or ""]
+    m = row.get("metadata_json")
+    if m:
+        try:
+            out += list(_strings(json.loads(m)))
+        except (ValueError, TypeError):
+            out.append(str(m))
+    return out
+
+
+def has_raw_html(row):
+    return any(RAW_HTML.search(s) for s in row_strings(row))
+
+
+def body_status(row):
+    import json
+    try:
+        return (json.loads(row.get("metadata_json") or "{}") or {}).get("body_status")
+    except (ValueError, TypeError, AttributeError):
+        return None
+
+
+def gate(law_rows, article_rows, card_counts, data_counts, heading_only_allowed=0, bodyless_check=False):
     """law_rows / article_rows: iterables of dicts (only the rows this pack adds). card_counts / data_counts: dicts of
     the numbers printed on the card vs recomputed from the parquet. heading_only_allowed: heading-only rows (whitespace-
-    collapsed text == title) the card discloses as kept (GI/territory one-line sections); 0 for DE (folded). Returns a dict; 'ok' is True only if all three pass."""
+    collapsed text == title) the card discloses as kept (GI/territory one-line sections); 0 for DE (folded). Raw HTML = generic tag
+    regex over title, text and every metadata_json string. Rows tagged metadata_json.body_status='repealed_placeholder' are counted
+    apart, not as heading-only. bodyless_check (DE): heading + footnote markers/digits only also counts as heading-only.
+    Returns a dict; 'ok' is True only if every check passes."""
     law_rows, article_rows = list(law_rows), list(article_rows)
     contents = [a.get("id") for a in article_rows if is_contents_row(a.get("title"))]
-    html_a = [a.get("id") for a in article_rows if RAW_HTML.search((a.get("text") or "") + "\n" + (a.get("title") or ""))]
-    html_l = [x.get("id") for x in law_rows if RAW_HTML.search((x.get("text") or "") + "\n" + (x.get("title") or ""))]
+    html_a = [a.get("id") for a in article_rows if has_raw_html(a)]
+    html_l = [x.get("id") for x in law_rows if has_raw_html(x)]
     diff = {k: {"card": card_counts.get(k), "data": data_counts.get(k)} for k in set(card_counts) | set(data_counts)
             if card_counts.get(k) != data_counts.get(k)}
-    heading_only = sum(1 for a in article_rows if is_heading_only(a.get("title"), a.get("text")))
+    repealed = [a.get("id") for a in article_rows if body_status(a) == "repealed_placeholder"]
+    heading_only_ids = [a.get("id") for a in article_rows if body_status(a) != "repealed_placeholder"
+                        and (is_heading_only(a.get("title"), a.get("text")) or (bodyless_check and is_bodyless(a.get("title"), a.get("text"))))]
+    heading_only = len(heading_only_ids)
     res = {"contents_rows": len(contents), "contents_row_ids": contents[:20],
            "raw_html_article_rows": len(html_a), "raw_html_law_rows": len(html_l), "raw_html_ids": (html_a + html_l)[:20],
            "card_matches_data": not diff, "card_vs_data_diff": diff,
-           "heading_only_rows": heading_only, "heading_only_allowed": heading_only_allowed, "heading_only_ok": heading_only == heading_only_allowed}
+           "heading_only_rows": heading_only, "heading_only_ids": heading_only_ids[:20], "heading_only_allowed": heading_only_allowed,
+           "heading_only_ok": heading_only == heading_only_allowed, "repealed_placeholder_rows": len(repealed)}
     res["ok"] = res["contents_rows"] == 0 and res["raw_html_article_rows"] == 0 and res["raw_html_law_rows"] == 0 and res["card_matches_data"] and res["heading_only_ok"]
     return res
 
@@ -128,8 +225,11 @@ def pack_gate(pack, laws_f, arts_f, card_text, extra_card=None, extra_data=None,
     import pyarrow.parquet as pq
     from pathlib import Path
     pack = Path(pack)
-    lt = pq.read_table(pack / laws_f, columns=["id", "title", "text"]).to_pylist()
-    at = pq.read_table(pack / arts_f, columns=["id", "title", "text"]).to_pylist()
+    def cols(f):
+        names = pq.read_schema(pack / f).names
+        return [c for c in ("id", "title", "text", "metadata_json") if c in names]
+    lt = pq.read_table(pack / laws_f, columns=cols(laws_f)).to_pylist()
+    at = pq.read_table(pack / arts_f, columns=cols(arts_f)).to_pylist()
     rows = card_file_rows(card_text)
     card = {f"rows:{laws_f}": rows.get(laws_f), f"rows:{arts_f}": rows.get(arts_f), **(extra_card or {})}
     data = {f"rows:{laws_f}": len(lt), f"rows:{arts_f}": len(at), **(extra_data or {})}

scrapers/pack_de.py

@@ -22,7 +22,8 @@ API = f"https://huggingface.co/api/datasets/{L.HUB_REPO}"
 RESOLVE = f"https://huggingface.co/datasets/{L.HUB_REPO}/resolve/{L.HUB_TIP}"
 BUNDLE = ["de_lib.py", "collect_de_laender.py", "pack_de.py", "robots_guard.py", "run_de_short.sh", "resume_loop_de.sh",
           "de_waiter.sh", "gate_profile.sh", "de_queue.example.txt", "requirements.txt", "README.md", "tests/test_de_laender.py",
-          "short_turn.sh", "tests/test_short_turn.py", "finalize_gate.py", "tests/test_finalize_gate.py", "fix_sn.py", "tests/test_fix_sn.py", "fix_contents_titles.py", "tests/test_fix_contents_titles.py", "fix_lawtext_br.py", "tests/test_fix_lawtext_br.py"]
+          "short_turn.sh", "tests/test_short_turn.py", "finalize_gate.py", "tests/test_finalize_gate.py", "fix_sn.py", "tests/test_fix_sn.py", "fix_contents_titles.py", "tests/test_fix_contents_titles.py", "fix_lawtext_br.py", "tests/test_fix_lawtext_br.py",
+          "refetch_de.py", "refetch_de.sh", "tests/test_sn_rework.py"]
 SECRET = re.compile(r"hf_[A-Za-z0-9]{30,}|ghp_[A-Za-z0-9]{30,}|github_pat_[A-Za-z0-9_]{30,}|AKIA[0-9A-Z]{16}|-----BEGIN [A-Z ]*PRIVATE KEY|xox[abps]-[A-Za-z0-9-]{10,}")
 
 
@@ -66,7 +67,14 @@ def as_version(r):
     return r
 
 
-CLEAN_KEYS = ("footnote_rows", "footnote_law_texts", "contents_dropped", "headings_folded", "headings_dropped", "titles_trimmed")
+CLEAN_KEYS = ("footnote_rows", "footnote_law_texts", "contents_dropped", "headings_folded", "headings_dropped", "titles_trimmed",
+              "norm_headings_dropped", "footnote_digit_rows_dropped", "attachment_stubs_dropped", "repealed_placeholders",
+              "metadata_html_cleaned", "folded_ids")
+GAP_KEYS = {"norm_headings_dropped": "empty norm heading (Artikel/§ with no body of its own on the revosax page, e.g. an Artikel that enacts a separate act); not merged into the next Artikel",
+            "footnote_digit_rows_dropped": "heading plus only a footnote number/marker, no body",
+            "attachment_stubs_dropped": "attachment stub (e.g. 'Anlagen' -> 'Karte'): the attachment itself is not on the page",
+            "headings_dropped": "trailing heading-only row (no following article to fold into)",
+            "contents_dropped": "contents-list row"}
 
 
 def load_records(land, tags=("-",), include_updates=False, clean_stats=None):
@@ -83,7 +91,7 @@ def load_records(land, tags=("-",), include_updates=False, clean_stats=None):
                 r = as_version(r)
             r, st = L.clean_record(r); r["_clean"] = st
             for k in CLEAN_KEYS:
-                cs[k] = cs.get(k, [] if isinstance(st[k], list) else 0) + st[k]
+                cs[k] = cs.get(k, [] if isinstance(st.get(k, 0), list) else 0) + st.get(k, 0)
             (rejected if r.get("bounds") else out).append(r)
     return out, rejected, updates
 
@@ -161,12 +169,36 @@ def finalize_gate(pack, n_old_laws, n_old_arts):
     cnt = {}
     for a in na:
         cnt[a["law_id"]] = cnt.get(a["law_id"], 0) + 1
-    res = G.gate(nl, na, card_counts((pack / "CARD_SECTION.md").read_text()), data)
+    card = card_counts((pack / "CARD_SECTION.md").read_text())
+    rd = pack / "README.md"
+    if rd.exists():  # cumulative README: its totals table must equal the written parquet
+        rc = readme_counts(rd.read_text(encoding="utf-8"))
+        card.update({f"readme:{k}": v for k, v in rc.items()})
+        jur = {x: j for x, j in zip(laws.column("id").to_pylist(), laws.column("jurisdiction").to_pylist())}
+        data.update({"readme:laws_total": laws.num_rows, "readme:laws_federal": sum(1 for j in jur.values() if j == "DE"),
+                     "readme:articles_total": arts.num_rows,
+                     "readme:articles_federal": sum(1 for x in arts.column("law_id").to_pylist() if jur.get(x) == "DE")})
+    res = G.gate(nl, na, card, data, bodyless_check=True)
     res["article_count_mismatch"] = sum(1 for x in nl if x["article_count"] != cnt.get(x["id"], 0))
-    res["ok"] = res["ok"] and res["article_count_mismatch"] == 0
+    mfs = sorted((pack / "manifests").glob("*_added_ids.jsonl")) if (pack / "manifests").exists() else []
+    mf = mfs[0] if len(mfs) == 1 else None
+    if mf is not None:  # manifest lists exactly the added law + article ids
+        man = [json.loads(x) for x in mf.read_text(encoding="utf-8").splitlines() if x.strip()]
+        res["manifest_matches_data"] = (sorted(m["id"] for m in man if m["table"] == "laws") == sorted(x["id"] for x in nl)
+                                        and sorted(m["id"] for m in man if m["table"] == "articles") == sorted(a["id"] for a in na))
+    else:
+        res["manifest_matches_data"] = False
+    res["ok"] = res["ok"] and res["article_count_mismatch"] == 0 and res["manifest_matches_data"]
     return res
 
 
+def readme_counts(text):
+    m1 = re.search(r"\| Laws / instruments \| (\d+) \(federal (\d+) \+ Landesrecht (\d+)\)", text or "")
+    m2 = re.search(r"\| Articles \| (\d+) \(federal (\d+) \+ Landesrecht (\d+)\)", text or "")
+    return {"laws_total": int(m1.group(1)) if m1 else None, "laws_federal": int(m1.group(2)) if m1 else None,
+            "articles_total": int(m2.group(1)) if m2 else None, "articles_federal": int(m2.group(2)) if m2 else None}
+
+
 def scan_tree(root):
     hits = []
     for p in Path(root).rglob("*"):
@@ -205,7 +237,7 @@ def cmd_build(a):
     out = stage_dir(a.land); pack = out / "pack"
     if pack.exists():
         shutil.rmtree(pack)
-    (pack / "data").mkdir(parents=True); (pack / "scrapers" / "tests").mkdir(parents=True)
+    (pack / "data").mkdir(parents=True); (pack / "scrapers" / "tests").mkdir(parents=True); (pack / "manifests").mkdir()
     pq.write_table(laws, pack / "data" / "laws.parquet", compression="zstd")
     pq.write_table(arts, pack / "data" / "articles.parquet", compression="zstd")
     for f in BUNDLE:
@@ -213,20 +245,42 @@ def cmd_build(a):
             print("bundle file missing", f); return 8
         shutil.copy2(HERE / f, pack / "scrapers" / f)
     rep["bounds_rejected"] = [r["law"]["id"] for r in rejected]
-    rep["pii_redactions"] = sum(r.get("pii_hits", 0) for r in recs)
+    rep["pii_redactions_all_records"] = sum(r.get("pii_hits", 0) for r in recs)  # every collected record, incl. ones not added
+    _mark = re.compile(r"\[REDACTED-[a-z_]+\]")
+    rep["pii_redactions"] = sum(len(_mark.findall(v or "")) for t, n0 in ((laws, rep["laws_old"]), (arts, rep["articles_old"]))
+                                for c in ("title", "text", "metadata_json") if c in t.column_names
+                                for v in t.column(c).to_pylist()[n0:])  # markers in the rows this pack adds
     rep["tip_updates_seen"] = updates; rep["tip_updates_included"] = bool(a.include_updates)
     added = set(laws.column("id").to_pylist()[rep["laws_old"]:]); ca = {}
     for r in recs:
         if r["law"]["id"] in added:
             for k in CLEAN_KEYS:
-                ca[k] = ca.get(k, [] if isinstance(r["_clean"][k], list) else 0) + r["_clean"][k]
+                ca[k] = ca.get(k, [] if isinstance(r["_clean"].get(k, 0), list) else 0) + r["_clean"].get(k, 0)
     rep["clean_up"] = {k: (len(v) if isinstance(v, list) else v) for k, v in ca.items()}  # rows this pack adds
     rep["clean_up_ids"] = {k: v for k, v in ca.items() if isinstance(v, list)}
     rep["clean_up_all_records"] = {k: (len(v) if isinstance(v, list) else v) for k, v in cs.items()}
     rep["source_terms_note"] = L.SOURCE_TERMS_NOTE
     rep["built_at"] = time.strftime("%Y-%m-%dT%H:%M:%S%z")
+    # 'dropped' = records NOT added because the row is already live (same id, or same title in the same Land): duplicates of live
+    # rows, not bounds rejections. bounds_rejected = pages with no norm text of their own (text < min_text_chars).
+    rep["not_added_duplicates_of_live_rows"] = {"total": len(rep["dropped"]),
+                                                "by_reason": {w: sum(1 for d in rep["dropped"] if d["why"] == w) for w in sorted({d["why"] for d in rep["dropped"]})}}
+    rep["bounds_rejected_reasons"] = {}
+    for r in rejected:
+        for b in r.get("bounds") or []:
+            rep["bounds_rejected_reasons"][b] = rep["bounds_rejected_reasons"].get(b, 0) + 1
+    rep["refetched_pages"] = sum(1 for r in recs if r["law"]["id"] in set(laws.column("id").to_pylist()[rep["laws_old"]:]) and refetched(a.land, r["law"]["id"]))
+    prefix = os.environ.get("DE_MANIFEST_PREFIX") or ("densify_" + a.land.lower() + "".join(f"_{t}" for t in tags if t and t != "-"))
+    rep["manifest_prefix"] = prefix
+    write_manifests(pack, prefix, laws, arts, rep, recs, rejected)
     (pack / "DENSIFY_REPORT.json").write_text(json.dumps(rep, ensure_ascii=False, indent=1))
     (pack / "CARD_SECTION.md").write_text(card_section(a.land, rep))
+    if getattr(a, "readme", None):
+        rep["_pack"] = str(pack)  # read by cumulative_readme only; never written to DENSIFY_REPORT.json
+        try:
+            (pack / "README.md").write_text(cumulative_readme(Path(a.readme).read_text(encoding="utf-8"), a.land, rep, laws, arts), encoding="utf-8")
+        finally:
+            rep.pop("_pack", None)
     g = finalize_gate(pack, rep["laws_old"], rep["articles_old"])
     rep["finalize_gate"] = g
     (pack / "DENSIFY_REPORT.json").write_text(json.dumps(rep, ensure_ascii=False, indent=1))
@@ -237,21 +291,134 @@ def cmd_build(a):
     if hits:
         print("secret scan hits", hits[:5]); return 7
     code = {f: sha256(pack / "scrapers" / f) for f in BUNDLE}
+    code["_notes"] = {"robots_guard.py": "robots_guard fa882316 (CoS 2026-10-17): adds 'rejected request|support id' to _CHALLENGE and a VERIFY_X509_STRICT-only TLS relax for 4 Taiwan hosts; no German host affected. Earlier DE packs were fetched with 1c9f28bc (one-hop, 2026-10-14)."}
     (pack / "scrapers" / "code.json").write_text(json.dumps(code, indent=1))
     sums = [f"{sha256(p)}  {p.relative_to(pack)}" for p in sorted(pack.rglob("*")) if p.is_file()]
     (pack / "SHA256SUMS").write_text("\n".join(sums) + "\n")
     print(json.dumps({k: v for k, v in rep.items() if k != "dropped"}), "dropped", len(rep["dropped"])); return 0
 
 
+def refetched(land, lid):
+    """True when the record was rebuilt from a page re-fetched by refetch_de.py (a records_prev/ copy exists)."""
+    rid = lid.split("-", 2)[2]
+    return any((d / "records_prev" / f"{lid}.json").exists() for d in WORK.glob(land.lower() + "*")) and bool(rid)
+
+
+def write_manifests(pack, prefix, laws, arts, rep, recs, rejected):
+    """manifests/<prefix>_added_ids.jsonl  every added law and article id (table, id[, law_id]);
+    <prefix>_known_gaps.jsonl  rows of the added laws that were dropped by the clean-up (id, law_id, reason) and the repeal
+    placeholders kept with metadata_json.body_status; <prefix>_not_added.jsonl  collected records not added: duplicates of live
+    rows (same id / same title in the same Land) and bounds rejections (no norm text of their own)."""
+    md = pack / "manifests"; md.mkdir(exist_ok=True)
+    nl, na = rep["laws_old"], rep["articles_old"]
+    with open(md / f"{prefix}_added_ids.jsonl", "w", encoding="utf-8") as f:
+        for i in laws.column("id").to_pylist()[nl:]:
+            f.write(json.dumps({"table": "laws", "id": i}, ensure_ascii=False) + "\n")
+        for i, l in zip(arts.column("id").to_pylist()[na:], arts.column("law_id").to_pylist()[na:]):
+            f.write(json.dumps({"table": "articles", "id": i, "law_id": l}, ensure_ascii=False) + "\n")
+    added = set(laws.column("id").to_pylist()[nl:])
+    gaps = []
+    for r in recs:
+        if r["law"]["id"] not in added:
+            continue
+        c = r["_clean"]
+        for k, why in GAP_KEYS.items():
+            for i in c.get(k) or []:
+                gaps.append({"id": i, "law_id": r["law"]["id"], "action": "dropped", "reason": k, "why": why})
+        for i in c.get("repealed_placeholders") or []:
+            gaps.append({"id": i, "law_id": r["law"]["id"], "action": "kept", "reason": "repealed_placeholder",
+                         "why": "repeal placeholder kept; metadata_json.body_status='repealed_placeholder'; stray footnote digits stripped"})
+    with open(md / f"{prefix}_known_gaps.jsonl", "w", encoding="utf-8") as f:
+        for g in gaps:
+            f.write(json.dumps(g, ensure_ascii=False) + "\n")
+    with open(md / f"{prefix}_not_added.jsonl", "w", encoding="utf-8") as f:
+        for d in rep["dropped"]:
+            f.write(json.dumps({"id": d["id"], "reason": "duplicate_of_live_row", "detail": d["why"]}, ensure_ascii=False) + "\n")
+        for r in rejected:
+            f.write(json.dumps({"id": r["law"]["id"], "reason": "no_norm_text", "detail": ",".join(r.get("bounds") or []),
+                                "title": (r["law"].get("title") or "")[:200], "text_chars": len(r["law"].get("text") or "")}, ensure_ascii=False) + "\n")
+    rep["known_gaps"] = {k: sum(1 for g in gaps if g["reason"] == k) for k in list(GAP_KEYS) + ["repealed_placeholder"]}
+    return gaps
+
+
+def _fmt(n):
+    return f"{n:,}"
+
+
+def cumulative_readme(live, land, rep, laws, arts):
+    """Full live README (as at the tip) + this batch: snapshot/totals rows updated, contents bullet, new section at the end."""
+    cfg = L.LANDS[land]; jur = cfg["jurisdiction"]; prefix = rep["manifest_prefix"]; day = rep["built_at"][:10]
+    ids = laws.column("id").to_pylist(); js = laws.column("jurisdiction").to_pylist()
+    jmap = dict(zip(ids, js)); fed_l = sum(1 for j in js if j == "DE")
+    fed_a = sum(1 for x in arts.column("law_id").to_pylist() if jmap.get(x) == "DE")
+    s = live
+    s = re.sub(r"(\| Snapshot date \| [^|\n]*?)( \|)", lambda m: m.group(1) + (f"; {jur} amending acts {day}" if f"{jur} amending acts" not in m.group(1) else "") + m.group(2), s, count=1)
+    s = re.sub(r"\| Laws / instruments \| \d+ \(federal \d+ \+ Landesrecht \d+\)", f"| Laws / instruments | {laws.num_rows} (federal {fed_l} + Landesrecht {laws.num_rows - fed_l})", s, count=1)
+    s = re.sub(r"\| Articles \| \d+ \(federal \d+ \+ Landesrecht \d+\)", f"| Articles | {arts.num_rows} (federal {fed_a} + Landesrecht {arts.num_rows - fed_a})", s, count=1)
+    bullet = (f"- `manifests/{prefix}_added_ids.jsonl` — every law and article id added by the {jur} amending-acts densify ({day}); "
+              f"`manifests/{prefix}_known_gaps.jsonl` — rows of those laws dropped by the clean-up (with reason) and the repeal placeholders kept; "
+              f"`manifests/{prefix}_not_added.jsonl` — collected records not added (duplicates of live rows; pages with no norm text).")
+    anchor = None
+    for anchor in re.finditer(r"^- `manifests/[^\n]*$", s, re.M):
+        pass
+    s = s[:anchor.end()] + "\n" + bullet + s[anchor.end():] if anchor else s.rstrip("\n") + "\n\n" + bullet + "\n"
+    k = rep.get("kinds", {}); cu = rep.get("clean_up", {}); kg = rep.get("known_gaps", {}); nd = rep["not_added_duplicates_of_live_rows"]
+    jl_old = sum(1 for j in js[:rep["laws_old"]] if j == jur)
+    ja_old = sum(1 for x in arts.column("law_id").to_pylist()[:rep["articles_old"]] if jmap.get(x) == jur)
+    gap_ids = {}
+    for g in (json.loads(x) for x in (Path(rep["_pack"]) / "manifests" / f"{prefix}_known_gaps.jsonl").read_text(encoding="utf-8").splitlines() if x.strip()):
+        gap_ids.setdefault(g["reason"], []).append(g["id"])
+    def ids_line(key):
+        v = gap_ids.get(key, [])
+        return ", ".join(f"`{i}`" for i in v)
+    sec = (f"\n## {jur} amending acts densify — {day} ({_fmt(rep['laws_added'])} laws / {_fmt(rep['articles_added'])} articles, append-only at {L.HUB_TIP[:8]})\n\n"
+           f"- Source: {cfg['host']} ({cfg['source_type']}); licence: {cfg['license']}\n"
+           f"- Kinds: {json.dumps(k, ensure_ascii=False)} — Änderungs-/Aufhebungsgesetze and -verordnungen (`metadata_json.metadata.kind` = `amending`), which the 2026-10-02 append and the 2026-10-15 densify excluded.\n"
+           f"- Every live row is byte-identical and comes first; only rows are appended (no live row changed or removed). New law and article ids are unique and disjoint from the tip; `article_count` = article rows for every added law.\n"
+           f"- Not added: {_fmt(nd['total'])} collected records are **duplicates of live rows** "
+           f"({', '.join(f'{_fmt(v)} {w}' for w, v in nd['by_reason'].items())}); listed in `manifests/{prefix}_not_added.jsonl`. "
+           f"(Earlier build logs called these 'dropped'; they are not bounds rejections.)\n"
+           f"- Not added: {_fmt(len(rep['bounds_rejected']))} REVOSax pages carry no norm text of their own (text under {L.BOUNDS['min_text_chars']} characters; "
+           f"stub pages that only point to a parent act, e.g. `Gesetz zum Zehnten Rundfunkänderungsstaatsvertrag`); listed in the same manifest.\n"
+           f"- Clean-up (pipeline, added rows only): revosax footnotes are `[n]` markers plus a plain-text `Fußnoten:` block ({cu.get('footnote_rows', 0)} article rows, "
+           f"{cu.get('footnote_law_texts', 0)} law texts converted at pack time); {cu.get('headings_folded', 0)} structural heading rows (Teil/Abschnitt/Zustimmungsgesetz, or an "
+           f"`Artikel N` heading over the § rows of the act it contains) folded into the next row; {cu.get('titles_trimmed', 0)} titles cleaned; "
+           f"{cu.get('metadata_html_cleaned', 0)} metadata fields cleaned of HTML. An empty `Artikel N` heading is never merged into Artikel N+1: each Artikel keeps its own text.\n"
+           f"- Repeal placeholders kept: {kg.get('repealed_placeholder', 0)} rows such as `Artikel 7 (außer Kraft)` / `(aufgehoben)` stay as rows, with stray footnote digits removed "
+           f"and `metadata_json.body_status` = `repealed_placeholder` (no new column; the dataset schema is unchanged): {ids_line('repealed_placeholder')}.\n"
+           f"- Personal data: only personal data of private individuals is redacted (`[REDACTED-<kind>]`); official accounts (Bundesbank / public cash offices), "
+           f"functional and authority mailboxes (e.g. `@sachsen.de`) and table numbers stay verbatim. Redaction markers in the added rows: {rep.get('pii_redactions', 0)}.\n"
+           f"- Pages re-fetched for this rebuild (robots-checked, gated, polite delay) and cached so later parser fixes re-parse offline: {rep.get('refetched_pages', 0)}.\n\n"
+           f"### Known gaps ({jur} amending acts)\n\n"
+           f"Rows of the added laws that are not in the data (every id with its reason is in `manifests/{prefix}_known_gaps.jsonl`):\n\n"
+           f"- {kg.get('norm_headings_dropped', 0)} empty `Artikel` headings with no body on the REVOSax page (mostly an Artikel that enacts a separate act, whose text "
+           f"REVOSax keeps under that act's own page): {ids_line('norm_headings_dropped')}.\n"
+           f"- {kg.get('footnote_digit_rows_dropped', 0)} heading rows with only a footnote number: {ids_line('footnote_digit_rows_dropped')}.\n"
+           f"- {kg.get('attachment_stubs_dropped', 0)} attachment stubs (the map / Anhang itself is not on the page): {ids_line('attachment_stubs_dropped')}.\n"
+           f"- {kg.get('headings_dropped', 0)} trailing heading-only rows (`Anlage`, `Anhang`, `Übersichtskarte` … with no content after them): listed in the manifest.\n\n"
+           f"### source_terms_note\n\n{L.SOURCE_TERMS_NOTE}\n\nEvery added row also carries `source_terms_note` inside `metadata_json.metadata`.\n\n"
+           f"{jur} totals after this batch: {_fmt(jl_old + rep['laws_added'])} laws ({_fmt(jl_old)} + {_fmt(rep['laws_added'])}) / "
+           f"{_fmt(ja_old + rep['articles_added'])} articles ({_fmt(ja_old)} + {_fmt(rep['articles_added'])}). "
+           f"Dataset totals: {_fmt(laws.num_rows)} laws / {_fmt(arts.num_rows)} articles.\n"
+           f"- The bundled `scrapers/de_lib.py` has default `HUB_TIP` {L.HUB_TIP[:8]} (the parent of this batch); set `DE_HUB_TIP` to the current tip before building a new pack.\n")
+    return s.rstrip("\n") + "\n" + sec
+
+
 def card_section(land, rep):
     cfg = L.LANDS[land]
     return (f"## {cfg['jurisdiction']} densify ({rep['laws_added']} laws / {rep['articles_added']} articles, append-only at {L.HUB_TIP[:8]})\n\n"
             f"- Source: {cfg['host']} ({cfg['source_type']}); licence: {cfg['license']}\n"
             f"- Kinds: {json.dumps(rep.get('kinds', {}), ensure_ascii=False)}\n"
+            + (f"- Not added: {rep['not_added_duplicates_of_live_rows']['total']} records that are duplicates of live rows "
+               f"({', '.join(f'{v} {w}' for w, v in rep['not_added_duplicates_of_live_rows']['by_reason'].items())}); "
+               f"{len(rep.get('bounds_rejected', []))} stub pages with no norm text of their own (they only point to a parent act)\n"
+               if "not_added_duplicates_of_live_rows" in rep else "")
             + (f"- Clean-up (pipeline, added rows only): {cu.get('contents_dropped', 0)} contents-list rows dropped; revosax footnote HTML converted "
                f"to plain-text 'Fußnoten:' blocks in {cu.get('footnote_rows', 0)} article rows and {cu.get('footnote_law_texts', 0)} law texts; "
                f"{cu.get('headings_folded', 0)} heading-only rows folded into the next article, {cu.get('headings_dropped', 0)} trailing ones dropped; "
-               f"{cu.get('titles_trimmed', 0)} titles cleaned\n" if (cu := rep.get("clean_up")) else "") + "\n"
+               f"{cu.get('titles_trimmed', 0)} titles cleaned; known gaps (dropped, listed in manifests/): {cu.get('norm_headings_dropped', 0)} empty Artikel headings, "
+               f"{cu.get('footnote_digit_rows_dropped', 0)} footnote-number-only rows, {cu.get('attachment_stubs_dropped', 0)} attachment stubs; "
+               f"{cu.get('repealed_placeholders', 0)} repeal placeholders kept (metadata_json.body_status)\n" if (cu := rep.get("clean_up")) else "") + "\n"
             f"### source_terms_note\n\n{L.SOURCE_TERMS_NOTE}\n\n"
             "Every added row also carries `source_terms_note` inside `metadata_json.metadata`.\n")
 
@@ -289,6 +456,7 @@ def main(argv=None):
     ap = argparse.ArgumentParser(); sp = ap.add_subparsers(dest="cmd", required=True)
     p = sp.add_parser("ids"); p.add_argument("--out", default=str(WORK / "hub_tip_ids.txt")); p.add_argument("--laws", default="")
     p = sp.add_parser("build"); p.add_argument("--land", required=True); p.add_argument("--live-laws", required=True); p.add_argument("--live-articles", required=True)
+    p.add_argument("--readme", default="", help="live README.md at the tip (read-only copy); the pack README = it + this batch's section")
     p.add_argument("--tags", default=None, help="comma list of sub-lanes, '-' = main (e.g. SN: '-,amending'; BB: vwv; NW: delta)")
     p.add_argument("--include-updates", action="store_true", help="NW: add tip_update records as separate '<id>@<valid_from>' version rows")
     p = sp.add_parser("stage"); p.add_argument("--land", required=True)

scrapers/refetch_de.py

@@ -0,0 +1,115 @@
+#!/usr/bin/env python3
+"""Targeted re-fetch / offline re-parse of already-collected DE Landesrecht records (added 2026-10-17 after CoS rejected the
+DE-SN amending densify: records had been redacted/parsed at fetch time and no raw page was kept).
+
+  refetch_de.py fetch   --land SN --tag amending --ids 4371,3982   # only ids with no cached page are fetched (run via refetch_de.sh:
+                                                                    # light gate + short-lane flock + 300 s stagger; robots_guard
+                                                                    # GuardedSession, scope check, per-host delay, challenge -> park)
+  refetch_de.py reparse --land SN --tag amending [--ids ...]        # offline: rebuild records from $DE_PAGE_CACHE with the current parser
+
+A rebuilt record keeps the law id, kind and tip_update flag; the previous record is kept once under records_prev/.
+Exit: 0 ok, 2 robots, 6 host park, 9 id has no record / no cached page (reparse).
+"""
+import argparse, gzip, json, sys, time
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE))
+import collect_de_laender as C  # noqa: E402  (sets LEGAL_CORPORA_ROOT for the guard)
+import de_lib as L  # noqa: E402
+import robots_guard as RG  # noqa: E402
+
+PARSE = {"SN": L.parse_sn_page, "BB": L.parse_bb_page, "NW": L.parse_nw_page}
+
+
+def lane(land, tag):
+    return C.Lane(land, set(), set(), tag)
+
+
+def rebuild(ln, rid, page, retrieved_at=None):
+    lid = L.law_id(ln.land, rid)
+    p = ln.rec / f"{lid}.json"
+    old = json.loads(p.read_text())
+    url = old["law"]["source_url"]
+    info = PARSE[ln.land](page, url)
+    info["kind"] = old.get("kind") or info.get("kind", "")
+    ts = retrieved_at or old["law"]["retrieved_at"]
+    law, arts, hits = L.make_rows(ln.land, info, url, ts)
+    out = dict(old, law=law, articles=arts, pii_hits=len(hits), bounds=L.check_bounds(info))
+    prev = ln.work / "records_prev" / p.name
+    if not prev.exists():
+        prev.parent.mkdir(parents=True, exist_ok=True); prev.write_text(p.read_text())
+    tmp = p.with_suffix(".tmp"); tmp.write_text(json.dumps(out, ensure_ascii=False)); tmp.replace(p)
+    return out
+
+
+def read_cache(ln, rid):
+    f = ln.pages / f"{rid}.html.gz"
+    return gzip.open(f, "rt", encoding="utf-8").read() if f.exists() else None
+
+
+def cmd_fetch(a):
+    ln = lane(a.land, a.tag)
+    ids = [x.strip() for x in a.ids.split(",") if x.strip()]
+    for rid in ids:
+        if not (ln.rec / f"{L.law_id(a.land, rid)}.json").exists():
+            print("no record", rid); return 9
+    if ln.parked.exists():
+        print("PARKED_host present; not fetching"); return C.RC_HOST_PARK
+    C.start_guard()  # collector hard floor (GATE_HARD_MIB from gate_profile.sh) + RSS cap
+    RG.set_country("de")
+    s = RG.GuardedSession()
+    s.headers.update({"User-Agent": RG.ROBOTS_UA, "Accept": "text/html,application/xml;q=0.9,*/*;q=0.5"})
+    log = []
+    try:
+        for rid in ids:
+            page = read_cache(ln, rid)
+            if page is not None:
+                log.append({"rid": rid, "cached": True}); continue
+            url = json.loads((ln.rec / f"{L.law_id(a.land, rid)}.json").read_text())["law"]["source_url"]
+            try:
+                page = ln.fetch_page(s, rid, url, "refetch")
+            except C.Transient as e:  # one retry after a pause, then skip the id (reported; a rerun picks it up, cached ids are not refetched)
+                print("transient", rid, str(e)[:200], flush=True); time.sleep(30)
+                try:
+                    page = ln.fetch_page(s, rid, url, "refetch")
+                except C.Transient as e2:
+                    log.append({"rid": rid, "failed": str(e2)[:200]}); print("failed", rid, flush=True); continue
+            rebuild(ln, rid, page, time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()))
+            log.append({"rid": rid, "fetched": True})
+            print("fetched", rid, flush=True)
+    except (RG.RobotsBlocked, C.RobotsTLS) as e:
+        print("robots", e); return C.RC_ROBOTS
+    except C.HostStop as e:
+        ln.parked.write_text(f"{time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime())} {str(e)[:300]}\n"); print("host stop", e); return C.RC_HOST_PARK
+    except C.Transient as e:
+        print("transient", e); return 9
+    finally:
+        print(json.dumps({"fetched": sum(1 for x in log if x.get("fetched")), "cached": sum(1 for x in log if x.get("cached")),
+                          "failed": [x["rid"] for x in log if x.get("failed")]}))
+    return 9 if any(x.get("failed") for x in log) else 0
+
+
+def cmd_reparse(a):
+    ln = lane(a.land, a.tag)
+    ids = [x.strip() for x in a.ids.split(",") if x.strip()] if a.ids else sorted(f.name.split(".")[0] for f in ln.pages.glob("*.html.gz"))
+    n = 0
+    for rid in ids:
+        page = read_cache(ln, rid)
+        if page is None or not (ln.rec / f"{L.law_id(a.land, rid)}.json").exists():
+            print("no cached page / record", rid); return 9
+        rebuild(ln, rid, page); n += 1
+    print("reparsed", n); return 0
+
+
+def main(argv=None):
+    ap = argparse.ArgumentParser(); sp = ap.add_subparsers(dest="cmd", required=True)
+    for c in ("fetch", "reparse"):
+        p = sp.add_parser(c); p.add_argument("--land", required=True, choices=sorted(PARSE)); p.add_argument("--tag", default="")
+        p.add_argument("--ids", required=(c == "fetch"), default="")
+    a = ap.parse_args(argv)
+    return {"fetch": cmd_fetch, "reparse": cmd_reparse}[a.cmd](a)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

scrapers/refetch_de.sh

@@ -0,0 +1,44 @@
+#!/bin/bash
+# Gated wrapper for refetch_de.py fetch (2026-10-17). Same gate as a DE short-lane slice: gate_profile.sh light/v2 start
+# MemAvailable + disk >= 12600 MiB held 120 s, then the shared short-lane flock with flock -n (never steals it; busy -> retry
+# from the gate), monotonic deadline REFETCH_WAIT_S (exit 74/75); honours and stamps the 300 s stagger; 30 min TERM timeout. The DE/GI turn files are NOT touched (no turn consumed).
+#   refetch_de.sh SN amending 4371,3982,...
+set -u
+CODE=$(cd "$(dirname "$0")" && pwd); . "$CODE/gate_profile.sh"
+PY=${DE_PYTHON:-/workspace/legal-corpora/.venv/bin/python}; WORK=${DE_WORK:-/workspace/de_laender/work}
+LOCK=${DE_LANE_LOCK:-/dev/shm/muni_runner.short.lock}; STAMP=${DE_LANE_STAMP:-/dev/shm/muni_last_start}
+WAIT=${REFETCH_WAIT_S:-7200}
+unset HF_TOKEN HUGGINGFACE_HUB_TOKEN HUGGING_FACE_HUB_TOKEN HF_HUB_TOKEN
+export DE_WORK=$WORK MALLOC_ARENA_MAX=2
+mono() { cut -d. -f1 /proc/uptime; }
+gate_profile "$WORK"; echo "[$(date -Is)] refetch gate profile $GATE_PROFILE (start $GATE_START_MIB MiB)"
+end_all=$(( $(mono) + WAIT ))
+while :; do
+  # gate first (nothing held), then the flock (-n, never steal), then a quick re-check of the start threshold
+  good=0
+  while :; do
+    m=$(awk '/MemAvailable/{print int($2/1024)}' /proc/meminfo); d=$(df -BM --output=avail /workspace | tail -1 | tr -dc 0-9)
+    if [ "$m" -ge "$GATE_START_MIB" ] && [ "$d" -ge 12600 ]; then good=$((good+5)); else good=0; fi
+    [ $good -ge 120 ] && break
+    [ "$(mono)" -ge $end_all ] && { echo "[$(date -Is)] gate/lock not obtained within ${WAIT} s (mem $m)"; exit 74; }
+    sleep 5
+  done
+  exec 9>"$LOCK"
+  if flock -n 9; then
+    m=$(awk '/MemAvailable/{print int($2/1024)}' /proc/meminfo)
+    [ "$m" -ge "$GATE_START_MIB" ] && { echo "[$(date -Is)] gate ok 120 s + short-lane flock held (mem $m MiB)"; break; }
+    flock -u 9
+  fi
+  exec 9>&-
+  [ "$(mono)" -ge $end_all ] && { echo "[$(date -Is)] short lane busy / gate lost until deadline"; exit 75; }
+  sleep 20
+done
+while :; do
+  last=$(stat -c %Y "$STAMP" 2>/dev/null || echo 0); now=$(date +%s)
+  [ $((now - last)) -ge 300 ] && break
+  sleep 15
+done
+( flock 8; date -Is > "$STAMP" ) 8>"$STAMP.lock"
+echo "[$(date -Is)] stagger ok; refetch_de.py fetch --land $1 --tag $2"
+timeout -s TERM 30m "$PY" "$CODE/refetch_de.py" fetch --land "$1" --tag "$2" --ids "$3"
+rc=$?; echo "[$(date -Is)] refetch rc=$rc"; exit $rc

scrapers/robots_guard.py

@@ -422,6 +422,132 @@ def ca_verify_for(url_or_host: str) -> object:
     return _default_ca()
 
 
+# --- per-host TLS: clear ONLY ssl.VERIFY_X509_STRICT (CoS GO 2026-10-16, Taiwan municipal law hosts) ------------
+# Python 3.13 / urllib3 2.3+ turn on VERIFY_X509_STRICT, which rejects some TW government certificates
+# ("Missing Subject Key Identifier") that OpenSSL otherwise verifies fine. For the EXACT hosts below (no subdomains,
+# no wildcards) the SSL context is the normal urllib3/certifi one with that single flag cleared:
+#   * verify_mode stays ssl.CERT_REQUIRED, check_hostname stays True, the full chain is still verified against
+#     certifi (or the host's registered CA bundle), all other verify_flags (e.g. VERIFY_X509_PARTIAL_CHAIN) unchanged;
+#   * verify=False is refused for these hosts (never used anywhere);
+#   * every use (context build and every request) is appended to <logdir>/tls/tls_relaxed_strict.jsonl.
+# Applied to the robots.txt fetch (_default_fetch) and to GuardedSession (and guarded_get/... wrappers). Not applied
+# to guarded_urlopen / guarded_curl_run (curl uses system OpenSSL, which does not enable X509_STRICT).
+import ssl as _ssl  # noqa: E402
+
+TLS_RELAX_STRICT_HOSTS = frozenset({
+    "laws.gov.taipei",           # Taipei City law system (臺北市法規查詢系統)
+    "www.laws.taipei.gov.tw",    # Taipei legacy host (301 -> laws.gov.taipei)
+    "web.law.ntpc.gov.tw",       # New Taipei City (新北市法規查詢系統)
+    "outlaw.kcg.gov.tw",         # Kaohsiung City (高雄市法規查詢系統)
+})
+
+
+class TLSPolicyError(ValueError):
+    """Refused TLS configuration (e.g. verify=False on a relaxed-strict host, or a host not on the allowlist)."""
+
+
+def tls_relax_strict_allowed(url_or_host: str) -> bool:
+    host = (urlsplit(url_or_host).hostname if "://" in url_or_host else url_or_host) or ""
+    return host.lower().strip(".") in TLS_RELAX_STRICT_HOSTS
+
+
+def _log_tls_relax(row: dict) -> None:
+    _append_jsonl(_logdir() / "tls" / "tls_relaxed_strict.jsonl", {"ts": _utc_iso(), "country": country(), **row})
+
+
+def relaxed_strict_ssl_context(host: str, cafile=None, caller: str = ""):
+    """SSL context for an allowlisted host: default verified context minus VERIFY_X509_STRICT only."""
+    host = (host or "").lower().strip(".")
+    if host not in TLS_RELAX_STRICT_HOSTS:
+        raise TLSPolicyError(f"host not on TLS_RELAX_STRICT_HOSTS: {host!r}")
+    try:
+        from urllib3.util.ssl_ import create_urllib3_context
+        ctx = create_urllib3_context(cert_reqs=_ssl.CERT_REQUIRED)
+    except Exception:  # pragma: no cover - urllib3 missing
+        ctx = _ssl.create_default_context()
+    if cafile is None:
+        cafile = ca_verify_for(host)
+    if isinstance(cafile, str) and os.path.isdir(cafile):
+        ctx.load_verify_locations(capath=cafile)
+    elif isinstance(cafile, str):
+        ctx.load_verify_locations(cafile=cafile)
+    else:
+        ctx.load_default_certs()
+    before = int(ctx.verify_flags)
+    ctx.verify_flags &= ~_ssl.VERIFY_X509_STRICT
+    ctx.verify_mode = _ssl.CERT_REQUIRED
+    ctx.check_hostname = True
+    assert ctx.verify_mode == _ssl.CERT_REQUIRED and ctx.check_hostname
+    assert not (ctx.verify_flags & _ssl.VERIFY_X509_STRICT)
+    _log_tls_relax({"event": "context", "host": host, "caller": caller, "cafile": str(cafile),
+                    "verify_flags_before": before, "verify_flags_after": int(ctx.verify_flags),
+                    "verify_mode": "CERT_REQUIRED", "check_hostname": True})
+    return ctx
+
+
+try:
+    from requests.adapters import HTTPAdapter as _HTTPAdapter
+
+    class _RelaxedStrictAdapter(_HTTPAdapter):
+        """HTTPS adapter bound to ONE allowlisted host; pools use relaxed_strict_ssl_context(host)."""
+
+        def __init__(self, host: str, caller: str = "", **kw):
+            self._rs_host = host.lower().strip(".")
+            if self._rs_host not in TLS_RELAX_STRICT_HOSTS:
+                raise TLSPolicyError(f"host not on TLS_RELAX_STRICT_HOSTS: {host!r}")
+            self._rs_caller = caller
+            super().__init__(**kw)
+
+        def init_poolmanager(self, *a, **kw):
+            kw["ssl_context"] = relaxed_strict_ssl_context(self._rs_host, caller=self._rs_caller)
+            return super().init_poolmanager(*a, **kw)
+
+        def proxy_manager_for(self, proxy, **kw):
+            kw["ssl_context"] = relaxed_strict_ssl_context(self._rs_host, caller=self._rs_caller + ":proxy")
+            return super().proxy_manager_for(proxy, **kw)
+
+        def send(self, request, **kw):
+            host = (urlsplit(request.url).hostname or "").lower()
+            if host != self._rs_host:
+                raise TLSPolicyError(f"relaxed adapter for {self._rs_host} got {host}")
+            if kw.get("verify") is False:
+                _log_tls_relax({"event": "refused_verify_false", "host": host, "url": request.url, "caller": self._rs_caller})
+                raise TLSPolicyError(f"verify=False refused for {host}")
+            _log_tls_relax({"event": "request", "host": host, "method": request.method, "url": request.url,
+                            "caller": self._rs_caller})
+            return super().send(request, **kw)
+
+    class TLSPolicyAdapter(_HTTPAdapter):
+        """Mounted on https:// : allowlisted hosts go through their _RelaxedStrictAdapter, all others unchanged."""
+
+        def __init__(self, caller: str = "", **kw):
+            self._caller, self._relaxed = caller, {}
+            super().__init__(**kw)
+
+        def send(self, request, **kw):
+            host = (urlsplit(request.url).hostname or "").lower().strip(".")
+            if urlsplit(request.url).scheme == "https" and host in TLS_RELAX_STRICT_HOSTS:
+                ad = self._relaxed.get(host)
+                if ad is None:
+                    ad = self._relaxed[host] = _RelaxedStrictAdapter(host, caller=self._caller)
+                return ad.send(request, **kw)
+            return super().send(request, **kw)
+
+        def close(self):
+            for ad in self._relaxed.values():
+                ad.close()
+            super().close()
+except Exception:  # pragma: no cover - requests missing
+    TLSPolicyAdapter = None  # type: ignore
+
+
+def mount_tls_policy(sess, caller: str = ""):
+    """Mount TLSPolicyAdapter on a requests.Session (no-op for objects without .mount, e.g. test fakes)."""
+    if TLSPolicyAdapter is not None and hasattr(sess, "mount"):
+        sess.mount("https://", TLSPolicyAdapter(caller=caller))
+    return sess
+
+
 # --- robots.txt redirect policy (CoS GO 2026-10-14 21:39 PT, "one-hop" fix) ---------------------------------------
 # Redirects on a robots.txt fetch are followed manually, one hop at a time:
 #   * same-host hop (scheme change allowed): followed, at most ROBOTS_MAX_HOPS hops in total;
@@ -482,6 +608,7 @@ def _default_fetch(robots_url: str):
     try:
         url, r, hops, seen = robots_url, None, 0, {robots_url}
         with requests.Session() as sess:
+            mount_tls_policy(sess, caller="robots_fetch")
             while True:
                 _robots_hop_clock(url, paced=hops > 0)
                 r = sess.get(url, timeout=ROBOTS_TIMEOUT, allow_redirects=False, verify=ca_verify_for(url),
@@ -520,7 +647,8 @@ def _default_fetch(robots_url: str):
 
 
 _CHALLENGE = re.compile(r"just a moment|cf-browser-verification|challenge-platform|captcha|awswaf|"
-                        r"checking your browser|enable javascript|request rejected|access denied", re.I)
+                        r"checking your browser|enable javascript|request rejected|access denied|"
+                        r"rejected request|support id", re.I)   # + F5 BIG-IP ASM page (CoS 2026-10-16; OCM/Senate KH)
 
 
 def _load_host(origin: str, host: str) -> HostState:
@@ -872,6 +1000,10 @@ try:
 
         min_interval: float = 0.0
 
+        def __init__(self, *a, **kw):
+            super().__init__(*a, **kw)
+            mount_tls_policy(self, caller="GuardedSession")   # per-host VERIFY_X509_STRICT relax (allowlist only)
+
         def send(self, request, **kwargs):
             guard_send(request.url, min_interval=self.min_interval, caller="GuardedSession")
             return super().send(request, **kwargs)

scrapers/tests/test_finalize_gate.py

@@ -100,6 +100,33 @@ class Gate(unittest.TestCase):
         self.assertTrue(g["ok"], g)
 
 
+class GenericHtml(unittest.TestCase):  # 2026-10-17: any tag, not a list; metadata strings too
+    def test_any_tag_name(self):
+        for t in ('<section data-anchor="1" data-level="1" title="Artikel 1" id="x1" >', "<wbr>", "</article>", "<o:p>", "<BR>",
+                  '<a href="/vorschrift/17134" title="A\nB">', 'Forstvermehrungsgutverordnung)">', "&lt;section id=\"x\"&gt;"):
+            self.assertTrue(G.RAW_HTML.search(t), t)
+        for t in ("– y <ER/SIE>", "§ 1 a < b > c", "<Name, Vorname>", "Wert <5 mg", "Text [1]"):
+            self.assertFalse(G.RAW_HTML.search(t), t)
+
+    def test_strip_removes_unlisted_tags_without_gluing(self):
+        t, _ = G.strip_html_footnotes('Präambel:\n<section data-anchor="1" title="Artikel 1 A\nB" id="x1" >\nArtikel 1')
+        self.assertEqual(t, "Präambel:\nArtikel 1"); self.assertIsNone(G.RAW_HTML.search(t))
+
+    def test_gate_scans_metadata_json(self):
+        row = {"id": "a:1", "title": "Artikel 2", "text": "Body", "metadata_json": '{"titel": "2 <a data-name=\'FAG\'>FAG</a>"}'}
+        g = G.gate([], [row], {}, {})
+        self.assertFalse(g["ok"]); self.assertEqual(g["raw_html_ids"], ["a:1"])
+        self.assertTrue(G.gate([], [dict(row, metadata_json='{"titel": "2 FAG"}')], {}, {})["ok"])
+
+    def test_body_status_repealed_placeholder_counted_apart(self):
+        row = {"id": "a:7", "title": "Artikel 7 (aufgehoben)", "text": "Artikel 7\n(aufgehoben)", "metadata_json": '{"body_status": "repealed_placeholder"}'}
+        g = G.gate([], [row], {}, {})
+        self.assertTrue(g["ok"], g); self.assertEqual((g["heading_only_rows"], g["repealed_placeholder_rows"]), (0, 1))
+        self.assertTrue(G.is_repeal_placeholder("Artikel 7 (außer Kraft)", "Artikel 7\n1\n(außer Kraft)"))
+        self.assertTrue(G.is_bodyless("Artikel 2 Änderung der X", "Artikel 2\nÄnderung der X 1"))
+        self.assertFalse(G.is_bodyless("Artikel 2 Änderung der X", "Artikel 2\nÄnderung der X\nIn § 1 wird ..."))
+
+
 class PackGate(unittest.TestCase):
     def test_pack_gate_card_rows_vs_parquet(self):
         import tempfile, pyarrow as pa, pyarrow.parquet as pq

scrapers/tests/test_sn_rework.py

@@ -0,0 +1,255 @@
+#!/usr/bin/env python3
+"""Offline tests for the 2026-10-17 DE-SN amending rework (CoS rejection): PII policy, revosax parser root causes, generic raw-HTML
+gate incl. metadata, norm-heading / repeal-placeholder clean-up, page cache + offline re-parse, pack manifests and cumulative README."""
+import gzip, json, os, sys, tempfile, unittest
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent; CODE = HERE.parent
+TMP = Path(tempfile.mkdtemp(prefix="de_rework_"))
+os.environ["DE_WORK"] = str(TMP / "work"); os.environ["DE_GUARD_ROOT"] = str(TMP / "guard")
+sys.path.insert(0, str(CODE))
+import de_lib as L  # noqa: E402
+import finalize_gate as G  # noqa: E402
+
+URL = "https://www.revosax.sachsen.de/vorschrift/99-Aend-X"
+
+
+class Pii(unittest.TestCase):
+    def test_table_numbers_are_not_tax_ids(self):
+        t = "152\n40 000\n160\n55 000\n165\n32 500 000\n200 und 12 345 678 901 Euro"
+        self.assertEqual(L.pii_scan(t), (t, []))
+
+    def test_tax_id_needs_label_and_one_line(self):
+        t, h = L.pii_scan("Steuer-Identifikationsnummer: 12 345 678 901 des Herrn X")
+        self.assertIn("[REDACTED-taxid]", t); self.assertEqual(h, [("taxid", "12 345 678 901")])
+        self.assertEqual(L.pii_scan("Steuer-ID\n\n\n\n" + "x" * 50 + " 12345678901")[1], [])
+
+    def test_official_ibans_stay(self):
+        for t in ("Bundeskasse Trier – Dienstsitz Kiel, IBAN:\nDE81 2100 0000 0021 0010 20, BIC: MARK DE F1 200 unter Angabe",
+                  "„IBAN: DE38 8600 0000 0086 0010 40, BIC: MARK DE F1 860“", "Landeshauptkasse Sachsen, IBAN DE22 8505 0300 3120 0001 23"):
+            self.assertEqual(L.pii_scan(t), (t, []), t)
+
+    def test_private_iban_redacted(self):
+        t, h = L.pii_scan("Herr Max Muster, IBAN DE89 3704 0044 0532 0130 00")
+        self.assertIn("[REDACTED-iban]", t); self.assertEqual(h[0][0], "iban")
+
+    def test_official_and_functional_mailboxes_stay(self):
+        for t in ("E-Mail-Adresse: datenschutzbeauftragter@smk.\xadsachsen.de.", "an phishing@lsf.sachsen.de zu senden",
+                  "poststelle@smi.sachsen.de", "datenschutz@example-verband.de"):
+            self.assertEqual(L.pii_scan(t), (t, []), t)
+        t, h = L.pii_scan("privat: max.muster@gmail.com")
+        self.assertEqual(t, "privat: [REDACTED-email]"); self.assertEqual(h, [("email", "max.muster@gmail.com")])
+
+
+PAGE = ('<html><h1>AendVO</h1><header class="x" title="Eingangsformel"><b>Verordnung</b><br/>der Staatsregierung zur Änderung der<br>'
+        'Infektionsschutzgesetz-Zuständigkeitsverordnung<p><b>Vom 5. Januar 2022</b></p></header>'
+        '<article id="lesetext">'
+        '<section data-anchor="1" data-level="1" title="Artikel&nbsp;1 Sächsisches<br>Wassergesetz (SächsWG)" id="a1"><h4>Artikel 1</h4>'
+        '<p>Sächsisches Wassergesetz<br>(SächsWG)</p></section>'
+        '<section data-anchor="1" data-level="1" title="Artikel 2 Verordnung<br/>der Staatsregierung\nzur Durchführung" data-link="a2" id="a2">'
+        '<p>Artikel 2</p><p>Verordnung</p><p>Text<a title="Artikel 2 tritt am\n1. Januar 2002 in Kraft" class="fussnote_link" href="#FNID_1"> 1</a>'
+        ' gilt. Siehe <a href="/vorschrift/17134" title="Sächsische\nOrdnung">SächsO</a>.</p></section>'
+        '<section data-anchor="1" data-level="1" id="a3"><p>Artikel 3</p><p>Inkrafttreten</p><p>Tritt in Kraft.</p></section>'
+        '</article></html>')
+
+
+class PiiTypo(unittest.TestCase):
+    def test_official_mailbox_with_printed_typo_kept(self):  # de-sn-20360
+        t = "Betreff an spammeldung@lit.justiz.sachsden.de zu senden."
+        self.assertEqual(L.pii_scan(t)[0] if isinstance(L.pii_scan(t), tuple) else t, t)
+        self.assertTrue(L.mail_is_official("spammeldung@lit.justiz.sachsden.de"))
+        self.assertFalse(L.mail_is_official("max.mustermann@gmx.de"))
+
+
+class Parser(unittest.TestCase):
+    def setUp(self):
+        self.i = L.parse_sn_page(PAGE, URL)
+
+    def test_title_br_is_a_space(self):
+        self.assertEqual(self.i["sections"][0]["title"], "Artikel\xa01 Sächsisches Wassergesetz (SächsWG)")
+        self.assertIn("der Infektionsschutzgesetz-Zuständigkeitsverordnung", self.i["title"])
+        self.assertNotIn("derInfektions", self.i["title"])
+
+    def test_gt_inside_attribute_keeps_title_and_text_clean(self):
+        s = self.i["sections"][1]
+        self.assertEqual(s["title"], "Artikel 2 Verordnung der Staatsregierung zur Durchführung"); self.assertEqual(s["anchor"], "a2")
+        self.assertNotIn('">', s["text"]); self.assertFalse(G.RAW_HTML.search(s["text"]))
+
+    def test_wrapped_anchor_and_footnote(self):
+        s = self.i["sections"][1]["text"]
+        self.assertIn("Text [1] gilt.", s); self.assertIn("SächsO", s)
+        self.assertTrue(s.endswith("Fußnoten:\n[1] Artikel 2 tritt am 1. Januar 2002 in Kraft"))
+        self.assertNotIn("<a", self.i["text"])
+
+    def test_no_title_attribute_falls_back_to_heading_not_anchor(self):
+        self.assertEqual(self.i["sections"][2]["title"], "Artikel 3")
+
+    def test_rows_have_no_html_anywhere(self):
+        law, arts, hits = L.make_rows("SN", dict(self.i, kind="amending"), URL, "t")
+        self.assertEqual(hits, [])
+        for r in [law] + arts:
+            self.assertFalse(G.has_raw_html(r), r["id"])
+
+
+class GenericGate(unittest.TestCase):
+    def test_any_tag_is_caught(self):
+        for t in ('x <section data-anchor="1" data-level="1" title="A" id="x1" > y', "<wbr>", "</div>", "<o:p>",
+                  'Verordnung)">\nArtikel 2', "&lt;section id=\"x\"&gt;", '<a href="/v/1" title="A\nB">T'):
+            self.assertTrue(G.RAW_HTML.search(t), t)
+        for t in ("– y <ER/SIE>", "§ 1 a < b > c", "<Name, Vorname>", "Wert <5 mg", "Text [1]"):
+            self.assertFalse(G.RAW_HTML.search(t), t)
+
+    def test_metadata_is_scanned(self):
+        row = {"id": "a", "title": "Artikel 2", "text": "T", "metadata_json": json.dumps(
+            {"titel": "2 Änderung des <a href='x' data-name='FAG'>Finanzausgleichsgesetzes</a> 1994"})}
+        g = G.gate([], [row], {}, {})
+        self.assertFalse(g["ok"]); self.assertEqual(g["raw_html_article_rows"], 1)
+
+    def test_repeal_placeholders_are_not_heading_only(self):
+        row = {"id": "a", "title": "Artikel 7 (außer Kraft)", "text": "Artikel 7\n(außer Kraft)",
+               "metadata_json": json.dumps({"body_status": "repealed_placeholder"})}
+        g = G.gate([], [row], {}, {}, bodyless_check=True)
+        self.assertTrue(g["ok"], g); self.assertEqual(g["repealed_placeholder_rows"], 1)
+
+    def test_bodyless_check(self):
+        row = {"id": "a", "title": "Artikel 2 Änderung der X", "text": "Artikel 2\nÄnderung der X 1"}
+        self.assertTrue(G.gate([], [row], {}, {})["ok"])
+        self.assertFalse(G.gate([], [row], {}, {}, bodyless_check=True)["ok"])
+
+
+def art(i, title, text):
+    return {"id": f"de-sn-9:{i}", "law_id": "de-sn-9", "title": title, "text": text,
+            "metadata_json": json.dumps({"doknr": i, "enbez": "Artikel", "titel": title})}
+
+
+class Clean(unittest.TestCase):
+    def rec(self, arts):
+        return {"kind": "amending", "law": {"id": "de-sn-9", "title": "G", "text": "x" * 100, "article_count": len(arts),
+                                            "metadata_json": json.dumps({"metadata": {"kind": "amending"}})}, "articles": arts}
+
+    def test_empty_artikel_is_not_merged_into_next_artikel(self):
+        r, st = L.clean_record(self.rec([art("a1", "Artikel\xa01 Gesetz über X (XG)", "Artikel 1\nGesetz über X\n(XG)"),
+                                         art("a2", "Artikel\xa02 Änderung", "Artikel 2\nÄnderung\nIn § 1 wird ...")]))
+        self.assertEqual([a["id"] for a in r["articles"]], ["de-sn-9:a2"])
+        self.assertEqual(r["articles"][0]["text"], "Artikel 2\nÄnderung\nIn § 1 wird ...")  # own text only
+        self.assertEqual(st["norm_headings_dropped"], ["de-sn-9:a1"]); self.assertEqual(st["headings_folded"], 0)
+
+    def test_artikel_heading_over_paragraphs_still_folds(self):
+        r, st = L.clean_record(self.rec([art("a1", "Artikel 1 Gesetz über X", "Artikel 1\nGesetz über X"),
+                                         art("p1", "§ 1 Zweck", "§ 1\nZweck\nDieses Gesetz ...")]))
+        self.assertEqual(st["folded_ids"], ["de-sn-9:a1"]); self.assertTrue(r["articles"][0]["text"].startswith("Artikel 1 Gesetz über X\n§ 1"))
+
+    def test_footnote_digit_row_and_attachment_stub_dropped(self):
+        r, st = L.clean_record(self.rec([art("a1", "Artikel 1 Änderung", "Artikel 1\nÄnderung\nText."),
+                                         art("a2", "Artikel\xa02  Änderung der OWi-ZuVO", "Artikel 2\nÄnderung der OWi-ZuVO 1"),
+                                         art("a3", "Artikel 3 Inkrafttreten", "Artikel 3\nInkrafttreten\nTritt in Kraft."),
+                                         art("x", "Anlagen", "Karte")]))
+        self.assertEqual(st["footnote_digit_rows_dropped"], ["de-sn-9:a2"]); self.assertEqual(st["attachment_stubs_dropped"], ["de-sn-9:x"])
+        self.assertEqual(r["law"]["article_count"], 2)
+
+    def test_repeal_placeholder_kept_tagged_digits_stripped(self):
+        r, st = L.clean_record(self.rec([art("a7", "Artikel\xa07 (außer Kraft)", "Artikel 7\n1\n(außer Kraft)"),
+                                         art("a8", "Artikel\xa02 (aufgehoben)", "Artikel 2\n(aufgehoben) 1"),
+                                         art("a9", "Artikel 9 Inkrafttreten", "Artikel 9\nInkrafttreten\nTritt in Kraft.")]))
+        a7, a8 = r["articles"][0], r["articles"][1]
+        self.assertEqual(a7["text"], "Artikel 7\n(außer Kraft)"); self.assertEqual(a8["text"], "Artikel 2\n(aufgehoben)")
+        self.assertEqual(json.loads(a7["metadata_json"])["body_status"], "repealed_placeholder")
+        self.assertEqual(st["repealed_placeholders"], ["de-sn-9:a7", "de-sn-9:a8"])
+        self.assertTrue(G.gate([r["law"]], r["articles"], {}, {}, bodyless_check=True)["ok"])
+
+    def test_metadata_html_cleaned(self):
+        a = art("a2", "Artikel 2 Änderung", "Artikel 2\nÄnderung\nText.")
+        a["metadata_json"] = json.dumps({"titel": "2 Änderung des <a href='x' data-name='FAG' data-id='162'>Finanzausgleichsgesetzes</a> 1994"})
+        r, st = L.clean_record(self.rec([a]))
+        self.assertEqual(json.loads(r["articles"][0]["metadata_json"])["titel"], "2 Änderung des Finanzausgleichsgesetzes 1994")
+        self.assertEqual(st["metadata_html_cleaned"], 1); self.assertFalse(G.has_raw_html(r["articles"][0]))
+
+
+class CacheReparse(unittest.TestCase):
+    def test_page_cached_and_reparsed_offline(self):
+        import collect_de_laender as C, refetch_de as R
+        lane = C.Lane("SN", {"amending"}, {"x"}, "rw")
+        lane.rec.mkdir(parents=True, exist_ok=True)
+        old = {"law": {"id": "de-sn-99", "source_url": URL, "retrieved_at": "2026-10-16T00:00:00Z"}, "articles": [], "kind": "amending",
+               "pii_hits": 3, "bounds": [], "tip_update": False}
+        (lane.rec / "de-sn-99.json").write_text(json.dumps(old))
+        lane.fetch = lambda s, url, kind: PAGE
+        page = lane.fetch_page(None, "99", URL)
+        self.assertTrue((C.PAGE_CACHE / "sn_rw" / "99.html.gz").exists())
+        self.assertEqual(gzip.open(C.PAGE_CACHE / "sn_rw" / "99.html.gz", "rt").read(), page)
+        self.assertFalse(str(C.PAGE_CACHE).startswith(str(C.BASE_WORK)))  # outside the lane tree (gate cap)
+        self.assertEqual(R.main(["reparse", "--land", "SN", "--tag", "rw", "--ids", "99"]), 0)
+        r = json.loads((lane.rec / "de-sn-99.json").read_text())
+        self.assertEqual(r["pii_hits"], 0); self.assertEqual(r["kind"], "amending"); self.assertEqual(len(r["articles"]), 3)
+        self.assertTrue((lane.work / "records_prev" / "de-sn-99.json").exists())
+        self.assertEqual(R.main(["reparse", "--land", "SN", "--tag", "rw", "--ids", "100"]), 9)
+
+
+@unittest.skipUnless((CODE / "pack_de.py").exists(), "DE bundle only")
+class PackOutputs(unittest.TestCase):
+    def test_readme_counts_and_manifests(self):
+        import pyarrow as pa, pack_de as P
+        live = ("# X\n\n## Snapshot\n\n| Field | Value |\n| --- | --- |\n| Snapshot date | 2026-09-05 (federal) |\n"
+                "| Laws / instruments | 2 (federal 1 + Landesrecht 1) |\n| Articles | 2 (federal 1 + Landesrecht 1) |\n\n## Contents\n\n"
+                "- `manifests/fix_x_ids.jsonl` — old.\n\n## Old section\n\nkeep me\n")
+        laws = pa.Table.from_pylist([{"id": "f", "jurisdiction": "DE"}, {"id": "de-sn-1", "jurisdiction": "DE-SN"}, {"id": "de-sn-9", "jurisdiction": "DE-SN"}])
+        arts = pa.Table.from_pylist([{"id": "f:1", "law_id": "f"}, {"id": "de-sn-1:1", "law_id": "de-sn-1"}, {"id": "de-sn-9:a2", "law_id": "de-sn-9"}])
+        pack = TMP / "pk"; (pack / "manifests").mkdir(parents=True, exist_ok=True)
+        rec = {"law": {"id": "de-sn-9"}, "_clean": {"norm_headings_dropped": ["de-sn-9:a1"], "repealed_placeholders": []}}
+        rep = {"laws_old": 2, "articles_old": 2, "laws_added": 1, "articles_added": 1, "dropped": [{"id": "de-sn-1", "why": "id_on_tip"}],
+               "bounds_rejected": ["de-sn-5"], "not_added_duplicates_of_live_rows": {"total": 1, "by_reason": {"id_on_tip": 1}},
+               "manifest_prefix": "densify_sn_amending", "built_at": "2026-10-17T05:00:00-0700", "_pack": str(pack), "kinds": {"amending": 1}}
+        P.write_manifests(pack, "densify_sn_amending", laws, arts, rep, [rec], [{"law": {"id": "de-sn-5", "title": "Stub", "text": ""}, "bounds": ["text_too_short"]}])
+        man = [json.loads(x) for x in (pack / "manifests" / "densify_sn_amending_added_ids.jsonl").read_text().splitlines()]
+        self.assertEqual(man, [{"table": "laws", "id": "de-sn-9"}, {"table": "articles", "id": "de-sn-9:a2", "law_id": "de-sn-9"}])
+        gaps = [json.loads(x) for x in (pack / "manifests" / "densify_sn_amending_known_gaps.jsonl").read_text().splitlines()]
+        self.assertEqual(gaps[0]["id"], "de-sn-9:a1")
+        na = [json.loads(x) for x in (pack / "manifests" / "densify_sn_amending_not_added.jsonl").read_text().splitlines()]
+        self.assertEqual([x["reason"] for x in na], ["duplicate_of_live_row", "no_norm_text"])
+        rd = P.cumulative_readme(live, "SN", rep, laws, arts)
+        self.assertTrue(rd.startswith(live.split("| Snapshot")[0])); self.assertIn("keep me", rd)
+        self.assertEqual(P.readme_counts(rd), {"laws_total": 3, "laws_federal": 1, "articles_total": 3, "articles_federal": 1})
+        self.assertIn("duplicates of live rows", rd); self.assertIn("`de-sn-9:a1`", rd); self.assertIn("densify_sn_amending_added_ids.jsonl", rd)
+        self.assertIn("DE-SN amending acts 2026-10-17", rd)
+
+
+class Respace(unittest.TestCase):
+    """de-sn-12867 / de-sn-19479: revosax drops a word break in one rendering of a heading only."""
+
+    def test_section_title_attribute_glue(self):
+        pg = ('<h1>Gesetz zur Änderung wasserrechtlicher Vorschriften</h1><article id="lesetext">'
+              '<section data-anchor="2" id="a1" title="Artikel 1 SächsischesWassergesetz (SächsWG)"><h4>Artikel 1\n<br>'
+              '<a href="/Text.link?stid=1" title="SächsWG">Sächsisches Wassergesetz\n<br>(SächsWG)</a></h4></section>'
+              '<section data-anchor="3" id="a2" title="Artikel 2 Inkrafttreten"><h4>Artikel 2<br>Inkrafttreten</h4>'
+              '<p>Dieses Gesetz tritt am Tag nach seiner Verkündung in Kraft.</p></section></article>')
+        r = L.parse_sn_page(pg, "https://www.revosax.sachsen.de/vorschrift/12867")
+        self.assertEqual(r["sections"][0]["title"], "Artikel 1 Sächsisches Wassergesetz (SächsWG)")
+
+    def test_eingangsformel_glue_and_hyphen_wrap(self):
+        pg = ('<h1 class="x">Sechste Verordnung zur Änderung der Infektionsschutzgesetz-\nZuständigkeitsverordnung</h1>'
+              '<p>Vollzitat: Sechste Verordnung zur Änderung der Infektionsschutzgesetz-\nZuständigkeitsverordnung vom 5. Januar 2022</p>'
+              '<article id="lesetext"><header data-anchor="1000" id="ef" title="Eingangsformel"><h3>Sechste Verordnung<br>'
+              'zur Änderung derInfektionsschutzgesetz-Zuständigkeitsverordnung</h3><p><b>Vom 5. Januar 2022</b></p></header>'
+              '<section id="a1" title="Artikel 1 Inkrafttreten"><h4>Artikel 1<br>Inkrafttreten</h4><p>Diese Verordnung tritt in Kraft.</p>'
+              '</section></article>')
+        r = L.parse_sn_page(pg, "https://www.revosax.sachsen.de/vorschrift/19479")
+        self.assertEqual(r["title"], "Sechste Verordnung zur Änderung der Infektionsschutzgesetz-Zuständigkeitsverordnung")
+        self.assertEqual(r["short_title"], r["title"])
+        self.assertNotIn("derInfektion", r["text"])
+
+    def test_different_wording_untouched(self):
+        self.assertEqual(L._respace("Artikel\xa01 Foo", "Artikel 1 Bar"), "Artikel\xa01 Foo")
+        self.assertEqual(L._respace("Artikel\xa01 FooBar", "Artikel 1 Foo Bar"), "Artikel\xa01 Foo Bar")
+
+
+class BodyReadTransient(unittest.TestCase):
+    def test_dropped_body_is_transient(self):
+        import collect_de_laender as C
+        import urllib3
+        src = Path(C.__file__).read_text()
+        self.assertIn("urllib3.exceptions.HTTPError", src)
+        self.assertTrue(issubclass(urllib3.exceptions.ProtocolError, urllib3.exceptions.HTTPError))
+
+
+if __name__ == "__main__":
+    unittest.main()