biblioteka_nauki: drop 4,142 reviewed rows, add per-record licence basis (v2#111) (#186)

- biblioteka_nauki: drop 4,142 reviewed rows, add per-record licence basis (v2#111) (f6263129635fe29a01984fe15539c7c0d26c06ea)

artifacts/source_findings.md

@@ -3670,3 +3670,85 @@ The texts themselves give no sign either way: none holds a footnote marker of WL
 **Not established** — the editors of the print editions and their death years; the first-edition form of any author
 name; what SpeakLeash changed and who removed the footer; whether WL's export drops author's footnotes in any book;
 whether `source_edition` is the edition the modernised text actually follows.
+
+## biblioteka_nauki — row review: 4,142 rows dropped, per-record licence basis added (update to the sections above)
+
+**Investigated** — 2026-10-20 (slayerlabs/polish-dynaword-v2#111).
+
+**Verdict** — kept; 4,142 of 41,985 documents dropped by a pinned row review (maintainer decisions 1A, 2A and 3 on
+v2#111, 2026-10-20): 41,985 → 37,843 documents (-9.9%), 1,739,004,913 → 1,534,529,869 characters, 669,909,430 →
+590,924,796 tokens (-78,984,634, -11.8%). Every kept row is identical to the shard before the review; the licence basis
+fields are new in the sidecar.
+
+**Method** — `src/clean_biblioteka_nauki.py` runs the existing filters, then `src/licence_basis_biblioteka_nauki.py`
+scans the text of every remaining row (front matter 4,000 characters, back matter 3,000, author check on the first
+8,000 and last 5,000) with the rules below. A row
+a rule nominates has one line in `data/biblioteka_nauki/biblioteka_nauki.review.csv` (`id,decision,reason`, pinned by
+SHA-256). The build fails when the rules and the table disagree, applies the drops, recomputes stats, evidence and
+sidecar in one run from the v0.2.5 shard and writes `licence_basis`, `licence_basis_url` and `licence_basis_date`. A
+row gets the first reason in the order printed licence, prior publication, file mismatch, restriction notice, year.
+The rules' measurements and the hand reads are in `data/biblioteka_nauki/biblioteka_nauki.licence-basis.json`.
+
+| decision: reason | documents | characters | tokens |
+|---|---:|---:|---:|
+| drop: created_before_licence_version | 3,957 | 181,784,176 | 70,103,154 |
+| drop: restriction_notice_no_cc_note | 97 | 14,700,907 | 5,882,338 |
+| drop: reprint_or_prior_publication | 30 | 1,475,398 | 531,012 |
+| drop: translation_of_earlier_publication | 17 | 902,932 | 346,552 |
+| drop: file_is_another_work | 16 | 1,237,708 | 455,178 |
+| drop: republished_by_permission | 11 | 1,359,754 | 504,063 |
+| drop: api_flagged_reprint_translation | 5 | 2,189,037 | 844,892 |
+| drop: translation_title_marker | 5 | 119,365 | 47,745 |
+| drop: printed_licence_nc_or_nd | 4 | 705,767 | 269,700 |
+| keep: text_garbled | 25 | 775,097 | 466,995 |
+| keep: same_author_prior_version | 5 | 295,509 | 117,106 |
+| keep: title_in_other_language | 5 | 193,470 | 74,078 |
+| keep: arr_only_no_cc_note | 5 | 2,104,519 | 804,452 |
+| keep: restriction_notice_beside_cc_note | 5 | 2,442,662 | 915,329 |
+| keep: not_a_notice_on_the_work | 5 | 158,813 | 61,768 |
+| keep: discusses_licence | 3 | 101,066 | 36,837 |
+| keep: item_found_later_in_file | 3 | 178,625 | 72,855 |
+| keep: printed_by_label_sa | 2 | 169,732 | 64,912 |
+| keep: translation_of_cc_original | 2 | 70,772 | 25,009 |
+| keep: front_matter_item | 2 | 6,914 | 2,880 |
+| keep: printed_sa_label_by | 1 | 482,353 | 185,072 |
+
+- **Year rule (decision 3)** — 3,989 rows have a `created` start year earlier than the first year of their label's
+  licence version (CC BY 2.0: 2004; 3.0 and 3.0 PL: 2007; 4.0: 2013): 3,989 documents, 184,805,600 characters,
+  71,278,767 tokens. 32 of them also meet an earlier drop reason and keep that reason (restriction notice 26,
+  another work 3, printed NC or ND 1, prior publication 1, translation 1); 7 that an earlier rule had read and kept
+  are dropped under the year rule (restriction notice beside a CC note 5, not a notice on the work 1, printed SA on a
+  CC BY label 1). So 3,957 documents carry the year reason; 3,950 of them are in no other rule's list. By label: CC
+  BY 4.0 2,279, CC BY-SA 4.0 1,470, CC BY 3.0 106, CC BY 3.0 PL 85, CC BY-SA 3.0 PL 49. In a seeded sample of 100 of
+  the 3,989, 90 print the `created` year in the first 8,000 or last 5,000 characters; the other 10 cite no later year.
+- **Journal adoption years could not be obtained** — the API returns a journal's current licence only, the shipped rows
+  carry no journal key, and asking for every item would take about 26 hours at the polite rate. Issues from before a
+  journal adopted Creative Commons may therefore remain where the publication year is not earlier than the licence
+  version. The year rule is a lower bound: the years are those of the generic licence texts (the Polish port may be
+  later, which would add rows), and the platform shows the licence an item has today.
+- **Printed NC/ND (4), another work (16), prior publication, permission and translation (63 rows), API flags (5)** —
+  decision 1A. 16 files are a different work from the one described: neither the title nor any author appears where the text
+  starts, ends or is attributed (all 51 candidates read; 30 each of two looser sets were sampled and none was another
+  work). Prior publication and translation rows were read in context for the tight families (reprint words in the front
+  matter, permission, earlier publication, title markers, translator credit, translation statement); the broad
+  translator-word family (1,326 rows, mostly footnotes) was not.
+- **Restriction notice, no CC note (97)** — decision 2A: the front or back matter prints a restriction on copying or
+  reproduction and no CC licence of its own. All 120 hits were read; 6 of the 110 hits outside `file_note` rows are not
+  a notice on the work. This is the weakest evidence of the drops: it is a reader's judgement that the printed
+  restriction contradicts the platform's CC label; no journal page was read to see which of the two the journal means.
+- **Licence basis** — `file_note` for 2,657 records (the text prints a CC licence with the label's elements; URL is
+  the item's page, date is the row's `added` date), `depositor` for 35,186 (only the platform's licence field states
+  it; URL is the API record, date 2026-10-05/2026-10-06). No record has `publisher` or `none`: no journal or publisher
+  page was read, and the 12 rows the API did not serve are withheld. A seeded sample of 60 `file_note` rows, read in
+  context, held 60 genuine notes of the work's own licence.
+
+**Kept as decided** — the 63 other nominated rows (a printed licence that belongs to an original or to a discussion of
+licences, "all rights reserved" beside a CC note or without a clause, unreadable text, another language, a revised
+version by the same authors), 8 translations of ancient, archival or literary texts by the item's author (the original
+is not a rights-held work; a 9th, `articles_534737`, is dropped as `reprint_or_prior_publication`), and the 16 rows
+that print "Wszelkie prawa zastrzeżone" or "All rights reserved" as written beside a CC API licence.
+
+**Not established** — journal adoption years; whether the platform's licence at publication equals the one it shows
+now for the rows the year rule does not catch; the false-negative rate of the `file_note` rule (licences printed in
+words or a form the parser does not read were not counted); whether the 97 restriction-notice drops would stand if the
+journals' own licence pages were read; recall of the reprint and translation rules beyond the tight families.

data/biblioteka_nauki/biblioteka_nauki.attribution.jsonl

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:b15b9b382b2975786f10f1d864fe1bcf34245c83a74eef0fa84320180c757dcc
-size 8563579
+oid sha256:aaf761cfb5e6f1e6a66721933e5cf09a7e9340e4fc2b10bd3944e70d61bd2b44
+size 13313905

data/biblioteka_nauki/biblioteka_nauki.licence-basis.json

@@ -0,0 +1,702 @@
+{
+  "added_dates": [
+    "2026-06-27"
+  ],
+  "api_flags": {
+    "biblioteka_nauki_articles_1194786": [
+      "reprintPublication"
+    ],
+    "biblioteka_nauki_articles_2154637": [
+      "translationPublication"
+    ],
+    "biblioteka_nauki_articles_508678": [
+      "reprintPublication"
+    ],
+    "biblioteka_nauki_books_1954543": [
+      "translationPublication"
+    ],
+    "biblioteka_nauki_books_2139603": [
+      "translationPublication"
+    ]
+  },
+  "by_code": {
+    "depositor": {
+      "characters": 1344777075,
+      "rows": 35186,
+      "tokens": 518747238
+    },
+    "file_note": {
+      "characters": 189752794,
+      "rows": 2657,
+      "tokens": 72177558
+    }
+  },
+  "by_label": {
+    "CC-BY-2.0": {
+      "depositor": 0,
+      "file_note": 1,
+      "none": 0,
+      "publisher": 0
+    },
+    "CC-BY-3.0": {
+      "depositor": 2306,
+      "file_note": 0,
+      "none": 0,
+      "publisher": 0
+    },
+    "CC-BY-3.0-PL": {
+      "depositor": 6825,
+      "file_note": 1124,
+      "none": 0,
+      "publisher": 0
+    },
+    "CC-BY-4.0": {
+      "depositor": 14460,
+      "file_note": 989,
+      "none": 0,
+      "publisher": 0
+    },
+    "CC-BY-SA-3.0": {
+      "depositor": 7,
+      "file_note": 0,
+      "none": 0,
+      "publisher": 0
+    },
+    "CC-BY-SA-3.0-PL": {
+      "depositor": 2651,
+      "file_note": 40,
+      "none": 0,
+      "publisher": 0
+    },
+    "CC-BY-SA-4.0": {
+      "depositor": 8937,
+      "file_note": 503,
+      "none": 0,
+      "publisher": 0
+    }
+  },
+  "codes": [
+    "file_note",
+    "publisher",
+    "depositor",
+    "none"
+  ],
+  "counts": {
+    "depositor": 35186,
+    "file_note": 2657,
+    "none": 0,
+    "publisher": 0
+  },
+  "created_before_licence_version": {
+    "by_label": {
+      "CC-BY-3.0": 106,
+      "CC-BY-3.0-PL": 85,
+      "CC-BY-4.0": 2279,
+      "CC-BY-SA-3.0-PL": 49,
+      "CC-BY-SA-4.0": 1470
+    },
+    "characters": 184805600,
+    "hand_check": "seeded sample of 100 of these rows: in 90 the `created` year is printed in the first 8000 or last 5000 characters; in the other 10 the text cites no later year than `created`",
+    "note": "a lower bound: the years are those of the generic licence texts (the Polish port may be later, which would add rows), and the platform shows the licence it has today, which may be later than the issue",
+    "overlap": {
+      "already_dropped_by_another_rule": {
+        "file_is_another_work": 3,
+        "printed_licence_nc_or_nd": 1,
+        "reprint_or_prior_publication": 1,
+        "restriction_notice_no_cc_note": 26,
+        "translation_of_earlier_publication": 1
+      },
+      "dropped_with_this_reason": 3957,
+      "flipped_from_keep": {
+        "not_a_notice_on_the_work": 1,
+        "printed_sa_label_by": 1,
+        "restriction_notice_beside_cc_note": 5
+      },
+      "not_otherwise_in_review": 3950
+    },
+    "precedence": "a row some other rule dropped keeps that rule's reason; a row only kept by another rule is dropped here",
+    "release_year": {
+      "CC-BY-2.0": 2004,
+      "CC-BY-3.0": 2007,
+      "CC-BY-3.0-PL": 2007,
+      "CC-BY-4.0": 2013,
+      "CC-BY-SA-3.0": 2007,
+      "CC-BY-SA-3.0-PL": 2007,
+      "CC-BY-SA-4.0": 2013
+    },
+    "rows": 3989,
+    "rule": "the `created` start year is earlier than the first year of the label's licence version; the row is dropped",
+    "tokens": 71278767
+  },
+  "dates": {
+    "depositor": "2026-10-05/2026-10-06",
+    "file_note": "the row's `added` date"
+  },
+  "hand_check": {
+    "file_note": "seeded sample of 60 of the file_note rows read in context: 60 genuine notes of the work's own licence (one carries a general 'unless stated otherwise' note of the publishing university)",
+    "not_measured": "rows with a licence printed in words or a form the parser does not read (false negatives of file_note) were not counted"
+  },
+  "hand_read": {
+    "file_mismatch": "all 51 rows read; the looser sets (title only absent: 476 rows, author only absent: 458, the 51 excluded) were sampled, 30 of each: 0 of the 60 were a different work (other language, encoding or front matter)",
+    "printed_note": "all 13 rows read",
+    "prior_publication": "every row with a hit of the tight families (reprint words in the front matter, permission, earlier publication, title markers, translator credit and translation statement) was read in context; the broad translator-word family (1,326 rows, mostly footnotes) was not. Rows read and not confirmed (prior_publication_any minus prior_publication_in_review) are not in the review",
+    "restriction_notice": "all 120 hits read in context; 6 of the 110 outside file_note rows are not a notice on the work"
+  },
+  "input": {
+    "license_api_sha256": "51e0bf7900e016f4b0102eecfd5032f3969a566899bf8ba094abad9f4f4578b5",
+    "rows_before_review": 41985,
+    "rows_before_review_content_sha256": "cc4ad9ce16aaef3c7bc5197743ad58182e3d5011f78cbf53896083e7a8541954",
+    "v0.2.5_parquet_sha256": "cc93cdd5ca3e6576a1da0aa294df1308e879b8516ac30911289e430c69a07b26"
+  },
+  "issue": "slayerlabs/polish-dynaword-v2#111",
+  "journal_adoption": {
+    "consequence": "an issue from before its journal adopted CC may remain wherever the publication year is not earlier than the licence version",
+    "obtainable": false,
+    "proxy": "created_before_licence_version",
+    "reason": "GET /api/journals/{id} returns the journal's current licence only, the shipped rows carry no journal key, and fetching every item takes about 26 hours at the polite rate"
+  },
+  "nominated_rows": {
+    "file_mismatch": 51,
+    "printed_note": 13,
+    "prior_publication": {
+      "earlier": 77,
+      "permission": 10,
+      "reprint_word": 180,
+      "title_reprint": 1,
+      "title_translation": 9,
+      "translation_statement": 220,
+      "translator_credit": 63
+    },
+    "prior_publication_any": 540,
+    "prior_publication_in_review": 73,
+    "restriction_notice": {
+      "arr_only/file_note": 6,
+      "arr_only/none": 8,
+      "clause/file_note": 4,
+      "clause/none": 102
+    }
+  },
+  "not_screened": {
+    "translations_of_source_texts": {
+      "characters": 270651,
+      "dropped_by_review": {
+        "biblioteka_nauki_articles_534737": "reprint_or_prior_publication"
+      },
+      "ids": [
+        "biblioteka_nauki_articles_1806845",
+        "biblioteka_nauki_articles_1806823",
+        "biblioteka_nauki_articles_1806867",
+        "biblioteka_nauki_articles_2057384",
+        "biblioteka_nauki_articles_1194054",
+        "biblioteka_nauki_articles_1917278",
+        "biblioteka_nauki_articles_699650",
+        "biblioteka_nauki_articles_555820"
+      ],
+      "note": "translations of ancient, archival or literary texts by the item's author; the original is not a rights-held work in the sense of the rule. One of the 9 is in the review under a prior-publication reason and is dropped (`dropped_by_review`)",
+      "rows": 8,
+      "tokens": 109996
+    }
+  },
+  "overlaps": {
+    "biblioteka_nauki_articles_1396194": [
+      "created_before_licence_version",
+      "file_is_another_work"
+    ],
+    "biblioteka_nauki_articles_2137969": [
+      "created_before_licence_version",
+      "translation_of_earlier_publication"
+    ],
+    "biblioteka_nauki_articles_336963": [
+      "created_before_licence_version",
+      "not_a_notice_on_the_work"
+    ],
+    "biblioteka_nauki_articles_371128": [
+      "created_before_licence_version",
+      "reprint_or_prior_publication"
+    ],
+    "biblioteka_nauki_articles_629493": [
+      "created_before_licence_version",
+      "file_is_another_work"
+    ],
+    "biblioteka_nauki_articles_697912": [
+      "created_before_licence_version",
+      "restriction_notice_no_cc_note"
+    ],
+    "biblioteka_nauki_articles_697939": [
+      "created_before_licence_version",
+      "restriction_notice_no_cc_note"
+    ],
+    "biblioteka_nauki_articles_697973": [
+      "created_before_licence_version",
+      "restriction_notice_no_cc_note"
+    ],
+    "biblioteka_nauki_articles_697985": [
+      "created_before_licence_version",
+      "restriction_notice_no_cc_note"
+    ],
+    "biblioteka_nauki_articles_697987": [
+      "created_before_licence_version",
+      "restriction_notice_no_cc_note"
+    ],
+    "biblioteka_nauki_articles_697989": [
+      "created_before_licence_version",
+      "restriction_notice_no_cc_note"
+    ],
+    "biblioteka_nauki_articles_697991": [
+      "created_before_licence_version",
+      "restriction_notice_no_cc_note"
+    ],
+    "biblioteka_nauki_articles_697993": [
+      "created_before_licence_version",
+      "restriction_notice_no_cc_note"
+    ],
+    "biblioteka_nauki_articles_697997": [
+      "created_before_licence_version",
+      "restriction_notice_no_cc_note"
+    ],
+    "biblioteka_nauki_articles_698011": [
+      "created_before_licence_version",
+      "restriction_notice_no_cc_note"
+    ],
+    "biblioteka_nauki_articles_698057": [
+      "created_before_licence_version",
+      "restriction_notice_no_cc_note"
+    ],
+    "biblioteka_nauki_articles_698309": [
+      "created_before_licence_version",
+      "restriction_notice_no_cc_note"
+    ],
+    "biblioteka_nauki_articles_916222": [
+      "created_before_licence_version",
+      "restriction_notice_no_cc_note"
+    ],
+    "biblioteka_nauki_articles_916223": [
+      "created_before_licence_version",
+      "restriction_notice_no_cc_note"
+    ],
+    "biblioteka_nauki_articles_916224": [
+      "created_before_licence_version",
+      "restriction_notice_no_cc_note"
+    ],
+    "biblioteka_nauki_articles_916225": [
+      "created_before_licence_version",
+      "restriction_notice_no_cc_note"
+    ],
+    "biblioteka_nauki_articles_916226": [
+      "created_before_licence_version",
+      "restriction_notice_no_cc_note"
+    ],
+    "biblioteka_nauki_articles_916227": [
+      "created_before_licence_version",
+      "restriction_notice_no_cc_note"
+    ],
+    "biblioteka_nauki_articles_916228": [
+      "created_before_licence_version",
+      "restriction_notice_no_cc_note"
+    ],
+    "biblioteka_nauki_articles_916229": [
+      "created_before_licence_version",
+      "restriction_notice_no_cc_note"
+    ],
+    "biblioteka_nauki_articles_916230": [
+      "created_before_licence_version",
+      "restriction_notice_no_cc_note"
+    ],
+    "biblioteka_nauki_articles_916235": [
+      "created_before_licence_version",
+      "restriction_notice_no_cc_note"
+    ],
+    "biblioteka_nauki_articles_916239": [
+      "created_before_licence_version",
+      "restriction_notice_no_cc_note"
+    ],
+    "biblioteka_nauki_articles_916240": [
+      "created_before_licence_version",
+      "restriction_notice_no_cc_note"
+    ],
+    "biblioteka_nauki_books_1076491": [
+      "created_before_licence_version",
+      "restriction_notice_beside_cc_note"
+    ],
+    "biblioteka_nauki_books_1076500": [
+      "created_before_licence_version",
+      "printed_licence_nc_or_nd"
+    ],
+    "biblioteka_nauki_books_1076514": [
+      "created_before_licence_version",
+      "restriction_notice_beside_cc_note"
+    ],
+    "biblioteka_nauki_books_1182283": [
+      "created_before_licence_version",
+      "printed_sa_label_by"
+    ],
+    "biblioteka_nauki_books_1389278": [
+      "created_before_licence_version",
+      "restriction_notice_beside_cc_note"
+    ],
+    "biblioteka_nauki_books_1409888": [
+      "created_before_licence_version",
+      "restriction_notice_beside_cc_note"
+    ],
+    "biblioteka_nauki_books_1623111": [
+      "created_before_licence_version",
+      "file_is_another_work",
+      "restriction_notice_no_cc_note"
+    ],
+    "biblioteka_nauki_books_1790306": [
+      "created_before_licence_version",
+      "restriction_notice_beside_cc_note"
+    ],
+    "biblioteka_nauki_books_1930491": [
+      "created_before_licence_version",
+      "restriction_notice_no_cc_note"
+    ],
+    "biblioteka_nauki_books_1954543": [
+      "api_flagged_reprint_translation",
+      "restriction_notice_no_cc_note"
+    ],
+    "biblioteka_nauki_books_949210": [
+      "created_before_licence_version",
+      "restriction_notice_no_cc_note"
+    ]
+  },
+  "platform_check": {
+    "answered_200": 42056,
+    "http404": 12,
+    "note": "the 12 http404 rows are withheld, so no shipped row has `none`; see biblioteka_nauki.license-evidence.json",
+    "retrieved": "2026-10-05..2026-10-06",
+    "rows_asked": 42068
+  },
+  "publisher_check": {
+    "done": false,
+    "note": "no journal or publisher page was read; the issue allows `publisher` as a second basis"
+  },
+  "regexes": {
+    "ARR": "(?i)wszelkie\\s+prawa\\s+(?:zastrzeżone|autorskie\\s+zastrzeżone)|wszystkie\\s+prawa\\s+zastrzeżone|all\\s+rights\\s+reserved|tous\\s+droits\\s+réservés|alle\\s+rechte\\s+vorbehalten",
+    "CLAUSE_AFTER_ARR": "(?i)nie\\s+(?:może|mogą)\\b|bez\\s+(?:pisemnej\\s+)?zgody|without\\s+(?:the\\s+)?(?:prior\\s+)?(?:written\\s+)?permission|zabronion|ograniczona",
+    "CONSENT": "(?i)(?:przedrukowywanie|przedruk\\w*|kopiowanie|powielanie|rozpowszechnianie|reprodukowanie|rozpowszechniania)[^.]{0,100}(?:bez\\s+(?:pisemnej\\s+|uprzedniej\\s+|uprzedniego\\s+)?(?:zgody|zezwolenia)|zabronion\\w+|wymaga\\w*\\s+zgody)|(?:reprint\\w*|reproduc\\w*|copying|redistribut\\w*|duplicat\\w*)[^.]{0,80}(?:without\\s+(?:the\\s+)?(?:prior\\s+)?(?:written\\s+)?(?:permission|consent)|prohibited|forbidden|not\\s+permitted)|bez\\s+(?:pisemnej\\s+)?zgody\\s+(?:wydawcy|autora|redakcji)|zabrania\\s+się\\s+(?:kopiowania|powielania|przedruk)|swoboda\\s+użytkownika\\s+ograniczona",
+    "R2_CREDIT": "(?:\\bPrzekład|\\bTłumaczenie|\\bTranslated by|\\bTranslation by|\\bPrzełożył[a]?|\\bTłumaczył[a]?|\\bTłum\\.|\\bPrzeł\\.|\\bPrzekład z [^.]{3,40}:)\\s*:?\\s*([A-ZŁŚŻŹĆ][a-ząęółśżźćńü\\-]{2,}(?:\\s+[A-ZŁŚŻŹĆ][a-ząęółśżźćńü\\-]{2,}){1,2})\\s*(?:[.\\n]|$|\\s(?=[A-Z0-9]))",
+    "R2_FRONT": {
+      "earlier": "(?i)\\b(?:first|originally|previously|earlier)\\s+(?:published|appeared)\\b|\\boriginally\\s+appeared\\b|\\bpublished\\s+(?:earlier|previously|originally|first)\\b|\\bpierwotnie\\s+(?:opublik|ukaza|wydan)\\w+|\\bukaza\\w+\\s+się\\s+(?:po\\s+raz\\s+pierwszy|wcześniej|pierwotnie|uprzednio)|\\b(?:publikowan|opublikowan|drukowan)\\w+\\s+(?:wcześniej|uprzednio|pierwotnie)",
+      "permission": "(?i)\\b(?:reprinted|reproduced|translated|published|republished|printed)\\s+(?:here\\s+)?(?:with|by)\\s+(?:the\\s+)?(?:kind\\s+)?permission|\\b(?:przedrukowan\\w+|przetłumaczon\\w+|opublikowan\\w+|zamieszczon\\w+|publikowan\\w+|tłumaczeni\\w+|wydan\\w+)\\s+(?:artyku\\w+\\s+)?(?:za|na)\\s+(?:zgodą|zezwoleniem|podstawie\\s+zgody)|\\bza\\s+(?:zgodą|zezwoleniem)\\s+(?:wydawcy|wydawnictwa|redakcji|właściciela\\s+praw)|kind\\s+permission",
+      "reprint_word": "(?i)\\bprzedruk\\w*|\\bpierwodruk\\w*|(?<![\\w-])reprint(?:ed)?\\b"
+    },
+    "R2_STATEMENT": "(?i)\\b(?:polish\\s+translation|polski\\s+przekład|przekład\\s+polski|tłumaczenie\\s+polskie|polskie\\s+tłumaczenie|translated\\s+(?:from|into)|przetłumaczon\\w+\\s+(?:z|na)|tłumaczenie\\s+(?:artyku|tekst)\\w*|przekład\\s+(?:artyku|tekst)\\w*|za\\s+zgodą\\s+autora\\s+tłumaczenia|tekst\\s+(?:został\\s+)?przełożon\\w+)",
+    "R2_TITLE": {
+      "title_reprint": "(?i)\\bprzedruk\\b|\\breprint\\b|\\(przedruk",
+      "title_translation": "(?i)\\((?:przekład|tłum\\w*|translation|translated)[^)]*\\)|\\[(?:przekład|tłum\\w*|translation)|\\bprzekład\\s+z\\b|\\btłumaczenie\\s+z\\b|\\btranslated\\s+from\\b|\\btranslation\\s+of\\b"
+    }
+  },
+  "review": {
+    "by_reason": {
+      "api_flagged_reprint_translation": {
+        "characters": 2189037,
+        "rows": 5,
+        "tokens": 844892
+      },
+      "arr_only_no_cc_note": {
+        "characters": 2104519,
+        "rows": 5,
+        "tokens": 804452
+      },
+      "created_before_licence_version": {
+        "characters": 181784176,
+        "rows": 3957,
+        "tokens": 70103154
+      },
+      "discusses_licence": {
+        "characters": 101066,
+        "rows": 3,
+        "tokens": 36837
+      },
+      "file_is_another_work": {
+        "characters": 1237708,
+        "rows": 16,
+        "tokens": 455178
+      },
+      "front_matter_item": {
+        "characters": 6914,
+        "rows": 2,
+        "tokens": 2880
+      },
+      "item_found_later_in_file": {
+        "characters": 178625,
+        "rows": 3,
+        "tokens": 72855
+      },
+      "not_a_notice_on_the_work": {
+        "characters": 158813,
+        "rows": 5,
+        "tokens": 61768
+      },
+      "printed_by_label_sa": {
+        "characters": 169732,
+        "rows": 2,
+        "tokens": 64912
+      },
+      "printed_licence_nc_or_nd": {
+        "characters": 705767,
+        "rows": 4,
+        "tokens": 269700
+      },
+      "printed_sa_label_by": {
+        "characters": 482353,
+        "rows": 1,
+        "tokens": 185072
+      },
+      "reprint_or_prior_publication": {
+        "characters": 1475398,
+        "rows": 30,
+        "tokens": 531012
+      },
+      "republished_by_permission": {
+        "characters": 1359754,
+        "rows": 11,
+        "tokens": 504063
+      },
+      "restriction_notice_beside_cc_note": {
+        "characters": 2442662,
+        "rows": 5,
+        "tokens": 915329
+      },
+      "restriction_notice_no_cc_note": {
+        "characters": 14700907,
+        "rows": 97,
+        "tokens": 5882338
+      },
+      "same_author_prior_version": {
+        "characters": 295509,
+        "rows": 5,
+        "tokens": 117106
+      },
+      "text_garbled": {
+        "characters": 775097,
+        "rows": 25,
+        "tokens": 466995
+      },
+      "title_in_other_language": {
+        "characters": 193470,
+        "rows": 5,
+        "tokens": 74078
+      },
+      "translation_of_cc_original": {
+        "characters": 70772,
+        "rows": 2,
+        "tokens": 25009
+      },
+      "translation_of_earlier_publication": {
+        "characters": 902932,
+        "rows": 17,
+        "tokens": 346552
+      },
+      "translation_title_marker": {
+        "characters": 119365,
+        "rows": 5,
+        "tokens": 47745
+      }
+    },
+    "decided": {
+      "drop": {
+        "characters": 204475044,
+        "rows": 4142,
+        "tokens": 78984634
+      },
+      "keep": {
+        "characters": 6979532,
+        "rows": 63,
+        "tokens": 2827293
+      }
+    },
+    "file": "biblioteka_nauki.review.csv",
+    "kept": {
+      "note": "SHA-256 of every column of the kept rows (id, text, source, added, created, token_count, license, author), as they were before the review; the test recomputes it from the shipped Parquet",
+      "rows": 37843,
+      "rows_sha256": "49a6272befa665daa9c36abd616c951efd0459e5d35a56adea1dc04440772744"
+    },
+    "note": "drops decided by the maintainer on 2026-10-20 (v2#111); the table lists every row a rule nominated, `drop` or `keep`, and nothing else",
+    "reasons": {
+      "drop": {
+        "api_flagged_reprint_translation": "the platform flags the item as a reprint or a translation (`reprintPublication` or `translationPublication`)",
+        "created_before_licence_version": "the `created` start year is earlier than the first year of the label's licence version (RELEASE), so the licence on the platform cannot have been the one chosen at publication",
+        "file_is_another_work": "neither the title nor any author of the description appears where the text starts, ends or is attributed; the file is a different work",
+        "printed_licence_nc_or_nd": "the text prints a NonCommercial or NoDerivatives licence; the platform's label is a CC BY or BY-SA licence",
+        "reprint_or_prior_publication": "the text says the work was published before, or is a reprint, in a place other than this platform",
+        "republished_by_permission": "the text says it is a reprint or a translation published with the permission of an author or publisher",
+        "restriction_notice_no_cc_note": "the front or back matter prints a restriction on copying or reproduction, and prints no CC licence of its own",
+        "translation_of_earlier_publication": "the text is a translation of a work published elsewhere, stated in the text or by a translator credit",
+        "translation_title_marker": "the citation title marks the item as a translation of a third party's text"
+      },
+      "keep": {
+        "arr_only_no_cc_note": "the front or back matter prints 'all rights reserved' without a clause and prints no CC licence of its own",
+        "discusses_licence": "the text discusses licences; the printed licence is not a note about the work",
+        "front_matter_item": "the item is a list of reviewers or of abbreviations; the description names a different item of the issue",
+        "item_found_later_in_file": "the title and author appear later in the file than the first 6000 characters",
+        "not_a_notice_on_the_work": "a phrase found by the rule is a quoted source, a discussion or a notice on something else",
+        "printed_by_label_sa": "the text prints CC BY; the label is CC BY-SA (the label is the less permissive)",
+        "printed_sa_label_by": "the text prints CC BY-SA; the label is CC BY (the label is the more permissive)",
+        "restriction_notice_beside_cc_note": "the front matter prints 'all rights reserved' or a restriction and, in the same front matter, a CC licence with the label's elements",
+        "same_author_prior_version": "the text is a revised or translated version of the authors' own earlier publication",
+        "text_garbled": "the text is not readable (shifted letters or noise), so no title or author can match; a data-quality issue, not a licence issue",
+        "title_in_other_language": "the title appears in another language than the description's",
+        "translation_of_cc_original": "the printed CC licence is the licence of the original that the text translates"
+      }
+    },
+    "rows": 4205,
+    "rule_order": [
+      "printed_note",
+      "prior_publication",
+      "file_mismatch",
+      "restriction_notice",
+      "created_before_licence_version"
+    ],
+    "sha256": "25e27c96280b6af547f2fdfb9d49a2d35861e96195a647047d6836af4a68a401",
+    "shipped": {
+      "characters": 1534529869,
+      "rows": 37843,
+      "tokens": 590924796
+    },
+    "source": {
+      "characters": 1739004913,
+      "rows": 41985,
+      "tokens": 669909430
+    }
+  },
+  "rule": "file_note: licence_basis.note_vs_label(text, label) is 'file_note', i.e. a CC note in the front or back matter, not about a photo or a quoted source, with the label's elements; depositor: every other row, whose label is the platform's licence object for the item",
+  "rules": {
+    "created_before_licence_version": {
+      "by_reason": {
+        "created_before_licence_version": {
+          "characters": 184805600,
+          "rows": 3989,
+          "tokens": 71278767
+        }
+      },
+      "nominated": "the `created` start year is earlier than RELEASE[label]"
+    },
+    "file_mismatch": {
+      "by_reason": {
+        "file_is_another_work": {
+          "characters": 1237708,
+          "rows": 16,
+          "tokens": 455178
+        },
+        "front_matter_item": {
+          "characters": 6914,
+          "rows": 2,
+          "tokens": 2880
+        },
+        "item_found_later_in_file": {
+          "characters": 178625,
+          "rows": 3,
+          "tokens": 72855
+        },
+        "text_garbled": {
+          "characters": 775097,
+          "rows": 25,
+          "tokens": 466995
+        },
+        "title_in_other_language": {
+          "characters": 193470,
+          "rows": 5,
+          "tokens": 74078
+        }
+      },
+      "nominated": "file_mismatch(text, citation)"
+    },
+    "printed_note": {
+      "by_reason": {
+        "discusses_licence": {
+          "characters": 101066,
+          "rows": 3,
+          "tokens": 36837
+        },
+        "printed_by_label_sa": {
+          "characters": 169732,
+          "rows": 2,
+          "tokens": 64912
+        },
+        "printed_licence_nc_or_nd": {
+          "characters": 705767,
+          "rows": 4,
+          "tokens": 269700
+        },
+        "printed_sa_label_by": {
+          "characters": 918857,
+          "rows": 2,
+          "tokens": 342323
+        },
+        "translation_of_cc_original": {
+          "characters": 70772,
+          "rows": 2,
+          "tokens": 25009
+        }
+      },
+      "nominated": "licence_basis.note_vs_label(...) == 'conflict'"
+    },
+    "prior_publication": {
+      "by_reason": {
+        "api_flagged_reprint_translation": {
+          "characters": 2189037,
+          "rows": 5,
+          "tokens": 844892
+        },
+        "reprint_or_prior_publication": {
+          "characters": 1475398,
+          "rows": 30,
+          "tokens": 531012
+        },
+        "republished_by_permission": {
+          "characters": 1359754,
+          "rows": 11,
+          "tokens": 504063
+        },
+        "same_author_prior_version": {
+          "characters": 295509,
+          "rows": 5,
+          "tokens": 117106
+        },
+        "translation_of_earlier_publication": {
+          "characters": 902932,
+          "rows": 17,
+          "tokens": 346552
+        },
+        "translation_title_marker": {
+          "characters": 119365,
+          "rows": 5,
+          "tokens": 47745
+        }
+      },
+      "nominated": "any regex family of R2 in the front matter or the citation title, or an API flag; the review lists only the rows whose reading confirmed a reprint, a translation or an earlier publication"
+    },
+    "restriction_notice": {
+      "by_reason": {
+        "arr_only_no_cc_note": {
+          "characters": 2104519,
+          "rows": 5,
+          "tokens": 804452
+        },
+        "not_a_notice_on_the_work": {
+          "characters": 185978,
+          "rows": 6,
+          "tokens": 72765
+        },
+        "restriction_notice_beside_cc_note": {
+          "characters": 4924931,
+          "rows": 10,
+          "tokens": 1848354
+        },
+        "restriction_notice_no_cc_note": {
+          "characters": 16296650,
+          "rows": 99,
+          "tokens": 6511000
+        }
+      },
+      "nominated": "restriction(text) is not None"
+    }
+  },
+  "source": "biblioteka_nauki",
+  "urls": {
+    "depositor": "https://bibliotekanauki.pl/api/{articles|books|chapters}/{n}",
+    "file_note": "https://bibliotekanauki.pl/{articles|books|chapters}/{n}"
+  }
+}

data/biblioteka_nauki/biblioteka_nauki.license-evidence.json

@@ -5,6 +5,7 @@
  "license_spdx": "MIXED (per row: CC-BY-2.0, CC-BY-3.0, CC-BY-3.0-PL, CC-BY-4.0, CC-BY-SA-3.0, CC-BY-SA-3.0-PL, CC-BY-SA-4.0)",
  "review_scope": "Licence name, URL and version of every one of the 42,068 rows of the previous release (v0.2.5 after the Public Domain Mark drop, Hub PR 62), read from the platform API. Not a review of the texts, of the authors' standing to license, or of third-party material inside the items.",
  "finding": "The API gives CC BY 2.0 / 3.0 / 3.0 PL / 4.0 and CC BY-SA 3.0 / 3.0 PL / 4.0 per record; v0.2.5 and the first v0.2.6 build collapsed all of them to 4.0 by keeping only license.iconId. The `license` column now holds the API's version. 12 rows the API no longer serves (HTTP 404) are withheld; so are, by the maintainer's decision of 2026-10-06, 56 rows whose text prints a NonCommercial or NoDerivatives licence and 15 rows whose text says it is reprinted or translated by permission of a publisher. articles_2011995 (API: CC BY-SA 4.0; earlier recovery: CC BY) is kept, labelled CC-BY-SA-4.0. No row's text changed.",
+ "after_the_review_of_2026_10_20": "The counts in this file (`shipped`, `withheld`, `flagged_action`, `verified`) describe the state of Hub PR 81, before the review of 2026-10-20 (polish-dynaword-v2#111): 4,142 of those 41,985 shipped rows are dropped, among them the 5 rows flagged as a reprint or translation. Current counts are in biblioteka_nauki.review.csv (the 4,205 reviewed rows, each with its decision and reason), biblioteka_nauki.licence-basis.json (the rules and measurements) and stats.json. The API licence per row is unchanged and still in biblioteka_nauki.license-api.json.",
  "upstream_api": "https://bibliotekanauki.pl/api/{articles|books|chapters}/{id}",
  "retrieved": "2026-10-05..2026-10-06",
  "retrieval_script": "data/biblioteka_nauki/recover_license_versions.py (one global request clock, 3 workers, 0.15 s between request starts, back-off on 429/5xx, stops on 403 or a non-JSON 200; no CAPTCHA or terms page was met)",

data/biblioteka_nauki/biblioteka_nauki.md

@@ -6,7 +6,7 @@ Biblioteka Nauki — Polish open-access scholarly corpus (scientific articles, b
 - **Source (upstream):** https://bibliotekanauki.pl (operated by ICM, University of Warsaw — Centrum Otwartej Nauki)
 - **Domain:** academic (scientific articles, books, chapters)
 - **Language:** Polish (pl)
-- **License:** per-document, with the version the upstream API gives for each record — CC BY (2.0, 3.0, 3.0 PL, 4.0) 28,280 · CC BY-SA (3.0, 3.0 PL, 4.0) 13,705; table below
+- **License:** per-document, with the version the upstream API gives for each record — CC BY (2.0, 3.0, 3.0 PL, 4.0) 25,705 · CC BY-SA (3.0, 3.0 PL, 4.0) 12,138; table below
 - **Created (range):** per-document publication year, from each item's bibliotekanauki.pl metadata
 - **Added:** 2026-06-27
 
@@ -22,21 +22,21 @@ name, URL, icon) on 2026-10-05/06, one request per row of the previous release
 | `license` label | documents | API licence (`nameEn`) |
 |---|---:|---|
 | CC-BY-2.0 | 1 | CC BY: Creative Commons Attribution 2.0 Generic |
-| CC-BY-3.0 | 2,413 | CC BY: Creative Commons Attribution 3.0 Unported |
-| CC-BY-3.0-PL | 8,098 | CC BY: Creative Commons Attribution 3.0 PL |
-| CC-BY-4.0 | 17,768 | CC BY: Creative Commons Attribution 4.0 |
+| CC-BY-3.0 | 2,306 | CC BY: Creative Commons Attribution 3.0 Unported |
+| CC-BY-3.0-PL | 7,949 | CC BY: Creative Commons Attribution 3.0 PL |
+| CC-BY-4.0 | 15,449 | CC BY: Creative Commons Attribution 4.0 |
 | CC-BY-SA-3.0 | 7 | CC BY-SA: Creative Commons Attribution-ShareAlike 3.0 Unported |
-| CC-BY-SA-3.0-PL | 2,754 | CC BY-SA: Creative Commons Attribution-ShareAlike 3.0 PL |
-| CC-BY-SA-4.0 | 10,944 | CC BY-SA: Creative Commons Attribution-ShareAlike 4.0 |
+| CC-BY-SA-3.0-PL | 2,691 | CC BY-SA: Creative Commons Attribution-ShareAlike 3.0 PL |
+| CC-BY-SA-4.0 | 9,440 | CC BY-SA: Creative Commons Attribution-ShareAlike 4.0 |
 
 The label is carried in the parquet `license` column. `src/clean_biblioteka_nauki.py` accepts a row only
 when the API licence is a Creative Commons BY or BY-SA licence of version 2.0 to 4.0 (generic or the
 Polish port), its `creativecommons.org` URL, English name and icon agree, and the kind matches the
 label recovered earlier. Anything else is withheld, not guessed (12 rows the API now answers with
 HTTP 404). `articles_2011995` is the one row whose API licence (CC BY-SA 4.0) differs from the earlier
-recovery (CC BY); it is kept and labelled CC-BY-SA-4.0 (maintainer decision 2026-10-06). Only the
-`license` column differs from the previous release; ids, order and text are unchanged for the 41,985
-rows shipped.
+recovery (CC BY); it is kept and labelled CC-BY-SA-4.0 (maintainer decision 2026-10-06). For the
+37,843 rows shipped, only the `license` column differs from the previous release; ids, order and text
+are unchanged.
 
 Three items labelled "Domena publiczna" were dropped for v0.2.6 (`src/clean_biblioteka_nauki.py`,
 polish-dynaword-v2#52): `books_2142716`, `books_2147851`, `articles_2097363` (376,155 tokens).
@@ -44,8 +44,8 @@ Biblioteka Nauki gives them API licence id 22, the CC Public Domain Mark 1.0, wh
 waiver or a licence. They are original works first published 2019-2022, so the Polish life+70 term has
 not run out, and `books_2147851` itself prints "Copyright by Jerzy Zając 2019".
 
-The API also flags 5 kept rows as a reprint (2) or translation (3) publication; none has `restricted`
-set. The licence check does not look at those flags.
+The API flags 5 rows as a reprint (2) or translation (3) publication; none has `restricted` set. The
+licence check does not look at those flags; the 5 rows are dropped in the review below.
 
 ## Withheld rows
 83 of the 42,068 rows of the previous release are not shipped. The ids, with one reason per id, are in
@@ -63,6 +63,55 @@ Rows are kept when the wording is only a citation, a quoted work's own notice, p
 types, a permission for a figure or table, or a translation permitted by the author alone. These
 readings are one reader's judgement of about 300 characters of context around each match.
 
+## Per-record licence basis
+Each line of `biblioteka_nauki.attribution.jsonl` also says what the row's licence rests on
+(polish-dynaword-v2#111): `licence_basis`, `licence_basis_url` and `licence_basis_date`.
+
+| `licence_basis` | rows | what it is | URL | date |
+|---|---:|---|---|---|
+| `file_note` | 2,657 | the text itself prints a CC licence with the label's elements in its front or back matter | the item's page on bibliotekanauki.pl | the row's `added` date |
+| `depositor` | 35,186 | only the platform's licence field for the item states it; the field is set when the item is uploaded | the item's record at `bibliotekanauki.pl/api/...` | 2026-10-05/2026-10-06, when it was read |
+
+No row has `publisher` or `none`: the journals' and publishers' own pages were not read, and the 12
+rows the API did not serve are withheld. The rules and their measurements are in
+`biblioteka_nauki.licence-basis.json`. A seeded sample of 60 `file_note` rows, read in context, held 60
+genuine notes of the work's own licence; rows that print a licence in a form the parser does not read
+were not counted.
+
+## Rows dropped after review
+4,142 of the 41,985 rows left by the steps above are dropped (polish-dynaword-v2#111, maintainer
+decisions of 2026-10-20). `biblioteka_nauki.review.csv` (`id,decision,reason`, pinned by SHA-256 in
+`src/clean_biblioteka_nauki.py`) lists the 4,205 rows a rule nominated, each with `drop` or `keep`, and
+nothing else; the build refuses to run when the rules and the table disagree.
+
+| reason | rows | what it is |
+|---|---:|---|
+| created_before_licence_version | 3,957 | the `created` start year is earlier than the first year of the label's licence version (CC BY 2.0: 2004; 3.0 and 3.0 PL: 2007; 4.0: 2013), so the licence the platform shows now cannot be the one chosen at publication |
+| restriction_notice_no_cc_note | 97 | the front or back matter prints a restriction on copying or reproduction and no CC licence of its own |
+| reprint_or_prior_publication | 30 | the text says the work was published before, or is a reprint, in a place other than this platform |
+| translation_of_earlier_publication | 17 | the text is a translation of a work published elsewhere, stated in the text or by a translator credit |
+| file_is_another_work | 16 | neither the title nor any author of the description appears where the text starts, ends or is attributed; the file is a different work |
+| republished_by_permission | 11 | the text says it is a reprint or a translation published with the permission of an author or publisher |
+| api_flagged_reprint_translation | 5 | the platform flags the item as a reprint or a translation |
+| translation_title_marker | 5 | the citation title marks the item as a translation of a third party's text |
+| printed_licence_nc_or_nd | 4 | the text prints a NonCommercial or NoDerivatives licence; the platform's label is a CC BY or BY-SA licence |
+
+A row gets the first reason in this order: printed licence, prior publication, file mismatch,
+restriction notice, year. 3,989 rows meet the year rule; 32 of them also meet an earlier drop reason and
+keep it, and 7 that an earlier rule had read and kept are dropped under the year rule. In a seeded sample
+of 100 rows dropped under it, 90 print the `created` year in the first 8,000 or last 5,000 characters,
+and the other 10 cite no later year.
+
+Journal adoption years could not be obtained: the platform's API gives a journal's current licence
+only, the shipped rows carry no journal key, and asking for every item would take about 26 hours. Issues
+from before a journal adopted Creative Commons may therefore remain where the publication year is not
+earlier than the licence version. The year rule is a lower bound: the years are those of the generic
+licence texts (the Polish port may be later), and the platform shows the licence an item has today.
+
+The other 63 nominated rows were read and stay: a printed licence that belongs to an original or to a
+discussion of licences, "all rights reserved" beside a CC note or without a clause, unreadable text,
+and similar. The reasons and counts are in the evidence file.
+
 ## Attribution
 Per-document attribution (author · year · title · publisher) was re-fetched 1:1 from
 bibliotekanauki.pl (43,576 / 43,576 ok). The parquet `author` column carries the author names and the
@@ -71,8 +120,9 @@ satisfying the CC BY / CC BY-SA attribution requirement that applies to every do
 
 `author` is the first field of that citation — the name(s), several joined by `; `. A footnote marker
 glued to the last name in the source (`… Kowol 1`) is dropped, and the `. .` placeholder used for the
-27 "Noty o autorach" pages with no single author becomes an empty value. The sidecar keeps the citation
-verbatim: one JSON object `{"id", "attribution"}` per row, in row order.
+25 "Noty o autorach" pages with no single author (27 before the review) becomes an empty value. The sidecar keeps the citation
+verbatim: one JSON object `{"id", "attribution", "licence_basis", "licence_basis_url",
+"licence_basis_date"}` per row, in row order.
 
 ## Provenance
 Text from the SpeakLeash redistribution; licence and attribution recovered per document from the
@@ -85,7 +135,7 @@ assembled is not re-verified here.
 ## Statistics
 | documents | characters | tokens (tiktoken proxy) |
 |---:|---:|---:|
-| 41,985 | 1,739,004,913 | 669,909,430 |
+| 37,843 | 1,534,529,869 | 590,924,796 |
 
 ## Filters applied (build_dynaword.py)
 Minimal, per Dynaword guidelines (heavy filtering left to downstream use):
@@ -97,7 +147,8 @@ Minimal, per Dynaword guidelines (heavy filtering left to downstream use):
 - licence not confirmed by the API as an allowlisted CC BY / BY-SA version, HTTP 404 (`src/clean_biblioteka_nauki.py`): **12**
 - text prints a NonCommercial or NoDerivatives licence (`src/clean_biblioteka_nauki.py`): **56**
 - text says it is reprinted or translated by permission of a publisher (`src/clean_biblioteka_nauki.py`): **15**
-- read 43,576 → kept 41,985
+- reviewed drops (`src/clean_biblioteka_nauki.py`, polish-dynaword-v2#111): **4,142**
+- read 43,576 → kept 37,843
 
 Token counts are a fast tiktoken (cl100k) proxy (~1% off Llama-3); the canonical
 Llama-3 count is computed at release.
@@ -106,9 +157,14 @@ Llama-3 count is computed at release.
 - **Mixed license.** Roughly one third of the documents are CC BY-SA (3.0, 3.0 PL or 4.0; share-alike);
   the exact per-document licence and version is in the `license` column. Downstream redistribution must
   respect share-alike for those documents, under their own version.
-- **Licence is the API's word.** About 120 texts contain the phrase "all rights reserved" although
-  their API licence is CC BY or CC BY-SA. The rows are kept; the conflict between a footer in the
-  extracted text and the platform's licence field is not resolved here.
+- **Licence is the API's word.** For 35,186 of the 37,843 rows the platform's licence field, set by
+  the depositor at upload, is the only statement of the licence; 2,657 also print it in their text.
+  No journal or publisher page was read. 16 texts contain the phrase "Wszelkie prawa zastrzeżone" or
+  "All rights reserved" as written, although their API licence is CC BY or CC BY-SA. The rows are
+  kept; the conflict between a footer in the extracted text and the platform's licence field is not
+  resolved here.
+- **Journal adoption.** Issues from before a journal adopted Creative Commons may remain; see "Rows
+  dropped after review".
 - **OCR / extraction noise.** Text is extracted from publisher PDFs; some layout and hyphenation
   artefacts remain after the alpha-ratio filter.
 - **Per-document dates.** `created` is the publication year from upstream metadata; finer-grained

data/biblioteka_nauki/biblioteka_nauki.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:655d070cbd5a0b7e441dd481197001f8991c793cdba3075310ff3696d2450a06
-size 1068112277
+oid sha256:8b031cd9c42921fc8478415a9d8ce79bacb41d2d98f5b24b89ef37065cdccb87
+size 941947131

data/biblioteka_nauki/biblioteka_nauki.stats.json

@@ -1,23 +1,23 @@
 {
   "read": 43576,
-  "kept": 41985,
+  "kept": 37843,
   "drop_short": 0,
   "drop_lang": 925,
   "drop_dup": 180,
   "drop_ocr": 400,
-  "chars": 1739004913,
-  "tokens": 669909430,
+  "chars": 1534529869,
+  "tokens": 590924796,
   "secs": 484.1,
   "license": "CC-BY-2.0 / CC-BY-3.0 / CC-BY-3.0-PL / CC-BY-4.0 / CC-BY-SA-3.0 / CC-BY-SA-3.0-PL / CC-BY-SA-4.0",
   "drop_rights": 3,
   "licenses": {
     "CC-BY-2.0": 1,
-    "CC-BY-3.0": 2413,
-    "CC-BY-3.0-PL": 8098,
-    "CC-BY-4.0": 17768,
+    "CC-BY-3.0": 2306,
+    "CC-BY-3.0-PL": 7949,
+    "CC-BY-4.0": 15449,
     "CC-BY-SA-3.0": 7,
-    "CC-BY-SA-3.0-PL": 2754,
-    "CC-BY-SA-4.0": 10944
+    "CC-BY-SA-3.0-PL": 2691,
+    "CC-BY-SA-4.0": 9440
   },
   "input_sha256": "cc93cdd5ca3e6576a1da0aa294df1308e879b8516ac30911289e430c69a07b26",
   "drop_license_unverified": 12,
@@ -106,7 +106,19 @@
     "biblioteka_nauki_books_2143725": "the text prints CC BY-NC 3.0 PL (its foreword says CC BY)",
     "biblioteka_nauki_books_2159317": "the text prints CC BY-NC-SA 4.0"
   },
-  "content_sha256": "cc4ad9ce16aaef3c7bc5197743ad58182e3d5011f78cbf53896083e7a8541954",
+  "content_sha256": "5093fd3ec52f5a6abfd11631a9f4f556d37fecdf21c29ad6246cf319086d7819",
   "drop_text_nc_nd": 56,
-  "drop_text_reprint": 15
+  "drop_text_reprint": 15,
+  "drop_review": 4142,
+  "drop_review_by_reason": {
+    "api_flagged_reprint_translation": 5,
+    "created_before_licence_version": 3957,
+    "file_is_another_work": 16,
+    "printed_licence_nc_or_nd": 4,
+    "reprint_or_prior_publication": 30,
+    "republished_by_permission": 11,
+    "restriction_notice_no_cc_note": 97,
+    "translation_of_earlier_publication": 17,
+    "translation_title_marker": 5
+  }
 }

src/biblioteka_nauki_overlap.py

@@ -2,7 +2,8 @@
 
 The biblioteka_nauki parquet carries only the canonical `author` column. The full citation
 (`Autor | Rok | Tytuł[ | Wydawca]`) is in data/biblioteka_nauki/biblioteka_nauki.attribution.jsonl, one
-`{"id", "attribution"}` per row, in row order (written by clean_biblioteka_nauki.split_attribution).
+`{"id", "attribution", ...}` per row, in row order (written by clean_biblioteka_nauki; the line also carries the `licence_basis*` fields,
+which this reader ignores).
 fetch_open_icm_pl, fetch_rock_pollub_pl and build_wiadomosci_statystyczne_pl read it from the Hub revision
 of main they run against; this module is their one reader, so the format is parsed in one place.
 """

src/clean_biblioteka_nauki.py

@@ -27,35 +27,55 @@ Maintainer decisions of 2026-10-06 (polish-dynaword-v2#57, Hub PR 81), applied b
                   permission (Oxford University Press and 12 other publishers or journals). Withheld.
 The build fails if a listed id is not reached, i.e. not among the rows that would otherwise be kept.
 
+Per-record licence basis and the reviewed drops (polish-dynaword-v2#111, maintainer decisions of 2026-10-20). The rows left by the
+steps above are scanned with src/licence_basis_biblioteka_nauki.py (the rules and the hand decisions). `biblioteka_nauki.review.csv`
+(`id,decision,reason`, pinned by SHA-256) holds one decision for every row a rule nominates and for nothing else; the build refuses to run
+when it differs from what the rules give. Rows it marks `drop` are removed: the 88 rows of the clear-cut reasons, the 97 rows with a
+restriction notice and no CC note of their own, and the rows whose `created` year is earlier than the first year of their label's licence
+version. A kept row is not changed (stats `content_sha256`, and the evidence file records a digest of every column of the kept rows).
+The attribution sidecar carries `licence_basis`, `licence_basis_url` and `licence_basis_date` from the same run.
+
 The v0.2.4 assembly script (build_parquet.py) was never committed, so this filters the shipped
 v0.2.5 Parquet, pinned by SHA-256, and updates the stats file in place. Rerun:
   git checkout v0.2.5 -- data/biblioteka_nauki/biblioteka_nauki.parquet
   python3 src/clean_biblioteka_nauki.py
+After a change to a rule or a hand decision, `--propose-review` rewrites the review table from the rules; read the diff and pin
+the new SHA-256 in REVIEW_SHA256.
 """
 from __future__ import annotations
 
 import argparse
 import hashlib
 import json
-import os
 import re
+import sys
 from collections import Counter
 from pathlib import Path
+from typing import Iterator, NamedTuple
 
 import pyarrow as pa
 import pyarrow.compute as pc
 import pyarrow.parquet as pq
 
-from biblioteka_nauki_overlap import ATTRIBUTION_SEP
-from normalize_schema import SCHEMA  # the canonical columns every shipped shard carries
-from sejm_api_common import check_pin
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+import licence_basis as lb  # noqa: E402
+import licence_basis_biblioteka_nauki as lbn  # noqa: E402
+from biblioteka_nauki_overlap import ATTRIBUTION_SEP  # noqa: E402
+from normalize_schema import SCHEMA  # noqa: E402  (the canonical columns every shipped shard carries)
+from sejm_api_common import check_pin, read_pinned_review, replace_all, sha256_file  # noqa: E402
 
 SOURCE = "biblioteka_nauki"
 DATA = Path(__file__).resolve().parents[1] / "data" / SOURCE
+PARQUET, STATS, ATTRIBUTION, EVIDENCE, REVIEW, LICENSE_API = (
+    DATA / f"{SOURCE}.{name}" for name in ("parquet", "stats.json", "attribution.jsonl", "licence-basis.json", "review.csv", "license-api.json"))
 INPUT_SHA256 = "cc93cdd5ca3e6576a1da0aa294df1308e879b8516ac30911289e430c69a07b26"  # v0.2.5
+LICENSE_API_SHA256 = "51e0bf7900e016f4b0102eecfd5032f3969a566899bf8ba094abad9f4f4578b5"  # the labels (and so the review) depend on it
+CLEANED_CONTENT_SHA256 = "cc4ad9ce16aaef3c7bc5197743ad58182e3d5011f78cbf53896083e7a8541954"  # content_digest of the rows left before the review
+REVIEW_SHA256 = "25e27c96280b6af547f2fdfb9d49a2d35861e96195a647047d6836af4a68a401"  # biblioteka_nauki.review.csv
+REVIEW_REASONS = {decision: set(group) for decision, group in lbn.REASONS.items()}
 KEEP = {"cc-by", "cc-by-sa", "cc0"}  # = CLEAN in data/biblioteka_nauki/recover_attribution.py
 DROP = {"public-domain"}  # CC Public Domain Mark: a label, not a grant (see docstring)
-SIDECAR = DATA / f"{SOURCE}.license-api.json"
+RESTORE = f"restore it with `git checkout v0.2.5 -- data/{SOURCE}/{SOURCE}.parquet`"
 # creativecommons.org/licenses/by/3.0/pl/legalcode, .../by-sa/4.0/legalcode.en, .../by/2.0/legalcode
 LICENSE_URL = re.compile(r"^https://creativecommons\.org/licenses/(by|by-sa)/(\d\.\d)/(?:([a-z]{2})/)?legalcode(?:\.[a-z]{2})?$")
 VERSIONS = {"2.0", "2.5", "3.0", "4.0"}
@@ -73,14 +93,9 @@ def split_author(citation: str) -> str:
     return author if _HAS_LETTER.search(author) else ""
 
 
-def split_attribution(table: pa.Table, sidecar_path: Path) -> pa.Table:
-    """Write the full per-document citation to a sidecar and keep the author names in the canonical `author`."""
-    ids = table.column("id").to_pylist()
+def split_attribution(table: pa.Table) -> pa.Table:
+    """The table in the canonical columns: the citation (`attribution`) is replaced by its author names (`author`)."""
     citations = table.column("attribution").to_pylist()
-    with sidecar_path.open("w", encoding="utf-8") as fh:
-        for row_id, citation in zip(ids, citations):
-            # default escaping: a citation may contain U+2028/U+2029, which must not read as a line break
-            fh.write(json.dumps({"id": row_id, "attribution": citation or ""}) + "\n")
     index = table.schema.get_field_index("attribution")
     table = table.set_column(index, "author", pa.array([split_author(c or "") for c in citations], pa.string()))
     return table.select(SCHEMA.names)
@@ -206,59 +221,151 @@ def withhold_listed(table: pa.Table, listed: dict[str, str]) -> tuple[pa.Table,
     return table.filter(pc.invert(pc.is_in(table.column("id"), pa.array(sorted(listed), pa.string())))), dict(listed)
 
 
-def content_digest(path: Path, skip: frozenset[str] = frozenset()) -> str:
-    """SHA-256 over every (id, SHA-256 of text) in file order, minus ids in `skip`. Equal digests mean the same
+def batches(source: Path | pa.Table, columns: list[str] | None = None) -> Iterator[pa.RecordBatch]:
+    if isinstance(source, Path):
+        yield from pq.ParquetFile(source).iter_batches(columns=columns, batch_size=2000)
+    else:
+        yield from source.select(columns or source.column_names).to_batches(max_chunksize=2000)
+
+
+def content_digest(source: Path | pa.Table, skip: frozenset[str] = frozenset()) -> str:
+    """SHA-256 over every (id, SHA-256 of text) in row order, minus ids in `skip`. Equal digests mean the same
     rows in the same order with the same text, whatever the other columns say."""
     digest = hashlib.sha256()
-    for batch in pq.ParquetFile(path).iter_batches(columns=["id", "text"], batch_size=2000):
+    for batch in batches(source, ["id", "text"]):
         for row_id, text in zip(batch.column("id").to_pylist(), batch.column("text").to_pylist()):
             if row_id not in skip:
                 digest.update(f"{row_id}\t{hashlib.sha256(text.encode()).hexdigest()}\n".encode())
     return digest.hexdigest()
 
 
-def build(input_path: Path, out_dir: Path) -> dict:
-    check_pin(input_path, INPUT_SHA256, f"restore it with `git checkout v0.2.5 -- data/{SOURCE}/{SOURCE}.parquet`")
-    table = pq.read_table(input_path)
+def rows_digest(source: Path | pa.Table, skip: frozenset[str] = frozenset()) -> str:
+    """SHA-256 over every column of every row in row order (the row as JSON, keys sorted), minus ids in `skip`."""
+    digest = hashlib.sha256()
+    for batch in batches(source):
+        for row in batch.to_pylist():
+            if row["id"] not in skip:
+                digest.update(json.dumps(row, ensure_ascii=False, sort_keys=True).encode() + b"\n")
+    return digest.hexdigest()
+
+
+def clean_table(table: pa.Table, api: dict, overrides: dict[str, str] = API_OVERRIDES, nc_nd: dict[str, str] = TEXT_NC_ND,
+                reprint: dict[str, str] = TEXT_REPRINT) -> tuple[pa.Table, dict[str, int], dict[str, str]]:
+    """The rows left after the licence steps (a rights label, the API's licence, the two hand lists), the stats counts of
+    what each step took, and {id: reason} for the withheld rows. `api` is the license-api sidecar."""
     granted = filter_table(table)
-    dropped = sorted(set(table.column("id").to_pylist()) - set(granted.column("id").to_pylist()))
-    labelled, api_withheld = relabel(granted, json.loads(SIDECAR.read_text(encoding="utf-8")), API_OVERRIDES)
-    labelled, nc_nd = withhold_listed(labelled, TEXT_NC_ND)
-    kept, reprint = withhold_listed(labelled, TEXT_REPRINT)
-    kept = split_attribution(kept, out_dir / f"{SOURCE}.attribution.jsonl")
-    withheld = {**api_withheld, **nc_nd, **reprint}
-    assert len(withheld) == len(api_withheld) + len(nc_nd) + len(reprint)
-
-    stats_path = out_dir / f"{SOURCE}.stats.json"
+    labelled, api_withheld = relabel(granted, api, overrides)
+    labelled, nc_nd_withheld = withhold_listed(labelled, nc_nd)
+    kept, reprint_withheld = withhold_listed(labelled, reprint)
+    withheld = {**api_withheld, **nc_nd_withheld, **reprint_withheld}
+    assert len(withheld) == len(api_withheld) + len(nc_nd_withheld) + len(reprint_withheld)
+    counts = {"drop_rights": table.num_rows - granted.num_rows, "drop_license_unverified": len(api_withheld),
+              "drop_text_nc_nd": len(nc_nd_withheld), "drop_text_reprint": len(reprint_withheld)}
+    return kept, counts, withheld
+
+
+class Screen(NamedTuple):
+    """The rows left after the licence steps, with what the rules say about them."""
+    cleaned: pa.Table
+    counts: dict[str, int]
+    withheld: dict[str, str]
+    recs: list[dict]
+    flags: dict[str, list[str]]
+    by_rule: dict[str, dict[str, tuple[str, str]]]
+    final: dict[str, tuple[str, str, str]]
+
+
+def screen(input_path: Path) -> Screen:
+    check_pin(input_path, INPUT_SHA256, RESTORE)
+    check_pin(LICENSE_API, LICENSE_API_SHA256, "the labels, and so the review, depend on it; it is the committed file")
+    api = json.loads(LICENSE_API.read_text(encoding="utf-8"))
+    cleaned, counts, withheld = clean_table(pq.read_table(input_path), api)
+    if (digest := content_digest(cleaned)) != CLEANED_CONTENT_SHA256:
+        raise SystemExit(f"the rows left before the review differ from the ones it was made for ({digest}, expected {CLEANED_CONTENT_SHA256})")
+    recs = lbn.scan(cleaned)
+    ids = set(cleaned.column("id").to_pylist())
+    flags = {i: f for i, f in api["flagged"].items() if i in ids}
+    by_rule = lbn.decisions(recs, set(flags))
+    return Screen(cleaned, counts, withheld, recs, flags, by_rule, lbn.final_reasons(by_rule))
+
+
+def read_review(path: Path = REVIEW, expected: str = REVIEW_SHA256) -> dict[str, tuple[str, str]]:
+    """id -> (decision, reason) from the pinned review table."""
+    return read_pinned_review(path, expected, f"it is not the reviewed {REVIEW.name}; `--propose-review` writes the one the rules give", REVIEW_REASONS)
+
+
+def check_review(review: dict[str, tuple[str, str]], final: dict[str, tuple[str, str, str]]) -> None:
+    """The review holds one decision for every row a rule nominates and for nothing else."""
+    proposed = lbn.proposed_review(final)
+    if review != proposed:
+        differing = sorted(i for i in review.keys() | proposed.keys() if review.get(i) != proposed.get(i))
+        raise SystemExit(f"the pinned review and the rules disagree on {len(differing)} ids, first {differing[:5]}; "
+                         "`--propose-review` writes what the rules give: read the difference, pin the new SHA-256")
+
+
+def build(input_path: Path, out_dir: Path, review_path: Path = REVIEW, expected_review: str = REVIEW_SHA256) -> dict:
+    scr = screen(input_path)
+    review = read_review(review_path, expected_review)
+    check_review(review, scr.final)
+    dropped = {i: reason for i, (decision, reason) in review.items() if decision == lbn.DROP}
+
+    pre_review = split_attribution(scr.cleaned)  # the shard as it was before the review
+    kept, _ = withhold_listed(pre_review, dropped)
+    skip = frozenset(dropped)
+    citations = [c for i, c in zip(scr.cleaned.column("id").to_pylist(), scr.cleaned.column("attribution").to_pylist()) if i not in skip]
+    kept_recs = [r for r in scr.recs if r["id"] not in skip]
+    lines = lbn.attribution_lines(kept_recs, citations)
+    if problems := lb.check_lines(lines, kept.column("id").to_pylist()):
+        raise SystemExit(f"the attribution sidecar does not fit the rows: {problems[:5]}")
+
+    stats_path = out_dir / STATS.name
     stats = json.loads(stats_path.read_text(encoding="utf-8"))  # keeps build_dynaword's read/drop_* counts
     stats.update(
         kept=kept.num_rows,
-        drop_rights=table.num_rows - granted.num_rows,
-        drop_license_unverified=len(api_withheld),
-        drop_text_nc_nd=len(nc_nd),
-        drop_text_reprint=len(reprint),
+        **scr.counts,
+        drop_review=len(dropped),
+        drop_review_by_reason=dict(sorted(Counter(dropped.values()).items())),
         chars=pc.sum(pc.utf8_length(kept.column("text"))).as_py(),
         tokens=pc.sum(kept.column("token_count")).as_py(),
         license=" / ".join(sorted(set(kept.column("license").to_pylist()))),
         licenses=dict(sorted(Counter(kept.column("license").to_pylist()).items())),
-        withheld=dict(sorted(withheld.items())),
+        withheld=dict(sorted(scr.withheld.items())),
         input_sha256=INPUT_SHA256,
+        content_sha256=content_digest(kept),
     )
-    parquet_tmp = out_dir / f"{SOURCE}.parquet.tmp"
-    stats_tmp = out_dir / f"{SOURCE}.stats.json.tmp"
-    pq.write_table(kept, parquet_tmp)
-    os.replace(parquet_tmp, out_dir / f"{SOURCE}.parquet")
-    stats["content_sha256"] = content_digest(out_dir / f"{SOURCE}.parquet")
-    stats_tmp.write_text(json.dumps(stats, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
-    os.replace(stats_tmp, stats_path)
-    return {**stats, "dropped_ids": dropped}
+    pinned = {
+        "review": {"file": review_path.name, "sha256": expected_review, "rows": len(review)},
+        "input": {"v0.2.5_parquet_sha256": INPUT_SHA256, "license_api_sha256": LICENSE_API_SHA256,
+                  "rows_before_review": scr.cleaned.num_rows, "rows_before_review_content_sha256": CLEANED_CONTENT_SHA256},
+        "kept": {"rows": kept.num_rows, "rows_sha256": rows_digest(pre_review, skip),
+                 "note": "SHA-256 of every column of the kept rows (id, text, source, added, created, token_count, license, author), as they were before the review; "
+                         "the test recomputes it from the shipped Parquet"},
+    }
+    evidence = lbn.evidence(scr.recs, scr.by_rule, scr.final, scr.flags, pinned)
+    replace_all({
+        out_dir / PARQUET.name: lambda path: pq.write_table(kept, path),
+        stats_path: lambda path: path.write_text(json.dumps(stats, indent=2, ensure_ascii=False) + "\n", encoding="utf-8"),
+        out_dir / ATTRIBUTION.name: lambda path: path.write_bytes(lbn.sidecar_bytes(lines)),
+        out_dir / EVIDENCE.name: lambda path: path.write_text(json.dumps(evidence, ensure_ascii=False, sort_keys=True, indent=2) + "\n", encoding="utf-8"),
+    })
+    return stats
+
+
+def propose_review(input_path: Path, review_path: Path = REVIEW) -> str:
+    """Write the review table the rules give; returns its SHA-256, to be pinned as REVIEW_SHA256."""
+    review_path.write_bytes(lbn.review_csv(screen(input_path).final).encode("utf-8"))
+    return sha256_file(review_path)
 
 
 def main() -> None:
     parser = argparse.ArgumentParser(description=__doc__.split("\n")[0])
-    parser.add_argument("--input", type=Path, default=DATA / f"{SOURCE}.parquet")
+    parser.add_argument("--input", type=Path, default=PARQUET)
     parser.add_argument("--out", type=Path, default=DATA)
+    parser.add_argument("--propose-review", action="store_true", help=f"write {REVIEW.name} from the rules and print its SHA-256; nothing else changes")
     args = parser.parse_args()
+    if args.propose_review:
+        print(f"{REVIEW}\nREVIEW_SHA256 = {propose_review(args.input)!r}")
+        return
     print(json.dumps(build(args.input, args.out), indent=2, ensure_ascii=False))
 
 

src/licence_basis.py

@@ -23,6 +23,24 @@ FIELDS = ("licence_basis", "licence_basis_url", "licence_basis_date")
 _DAY = r"\d{4}-\d{2}-\d{2}"
 DATE = re.compile(rf"^{_DAY}(/{_DAY})?$")
 
+CREATED_BEFORE = "created_before_licence_version"  # the drop reason of the year rule: `created` is earlier than the first year of the label's licence version
+RELEASE = {"CC-BY-2.0": 2004, "CC-BY-3.0": 2007, "CC-BY-3.0-PL": 2007, "CC-BY-SA-3.0": 2007, "CC-BY-SA-3.0-PL": 2007,
+           "CC-BY-4.0": 2013, "CC-BY-SA-4.0": 2013}  # first year of the licence version (generic text; the Polish port may be later)
+
+
+def created_year(created: str) -> int:
+    """The start year of a `created` value ("2011", "2021-05", "2024-01-31"); raises for a value that does not start with four digits."""
+    if not re.match(r"[0-9]{4}", created):
+        raise ValueError(f"no start year in the created value {created!r}")
+    return int(created[:4])
+
+
+def release_year(label: str) -> int:
+    """First year of the label's licence version; raises for a label RELEASE does not list (the rule needs a year for every label)."""
+    if label not in RELEASE:
+        raise ValueError(f"no release year for the licence label {label!r}; add it to RELEASE")
+    return RELEASE[label]
+
 _DASH = r"[\s\-‐-―]*"
 _ANCHOR = re.compile(r"(?i)creativecommons\.org/licen[sc]es/|creative\s*commons|\bCC" + _DASH + r"BY\b|\bCC0\b")
 _URL_KIND = re.compile(r"(?i)licen[sc]es/(by(?:-nc)?(?:-sa|-nd)?)/(\d\.\d)")

src/licence_basis_biblioteka_nauki.py

@@ -0,0 +1,411 @@
+#!/usr/bin/env python3
+"""Per-record licence basis and the reviewed drops for biblioteka_nauki (v0.2.6, slayerlabs/polish-dynaword-v2#111).
+
+The rules, the hand decisions and the evidence file. src/clean_biblioteka_nauki.py runs them in its build, on the rows it
+would otherwise ship, and applies the pinned review table; nothing here is run on its own.
+
+Adds `licence_basis`, `licence_basis_url` and `licence_basis_date` (src/licence_basis.py) to each attribution line:
+  file_note  the shipped text prints a CC licence with the label's elements (licence_basis.note_vs_label);
+             URL: the item's page on bibliotekanauki.pl; date: the row's `added` date
+  depositor  only the platform's licence field states it (https://bibliotekanauki.pl/api/{articles|books|chapters}/{n}, read 2026-10-05/06);
+             the field is set when the item is uploaded
+No `publisher` basis was looked for: the journals' own pages were not read. No row has `none`: the 12 rows the API did not serve are
+already withheld.
+
+Review (`biblioteka_nauki.review.csv`: `id,decision,reason`, decision `drop` or `keep`) lists every row that a rule in PRIORITY
+nominates and that someone decided. The first `drop` in PRIORITY order gives a row its reason; a row some rule dropped keeps
+that reason when a later rule nominates it too; a row only `keep`-decided by an earlier rule is dropped by a later `drop`.
+A new rule is a new entry in PRIORITY, in `decisions` and in REASONS; the build refuses a pinned table that differs from what the
+rules give. Maintainer decisions of 2026-10-20 (v2#111): the 88 rows of the clear-cut reasons, the 97 `restriction_notice_no_cc_note`
+rows and the rows created before their licence version existed are dropped; the other review rows are kept.
+
+`biblioteka_nauki.licence-basis.json` holds the counts, the rules with their measurements and hand checks, and the drops.
+The screens were measured on the 41,985 rows before the review; the ids decided by hand are listed in HAND below and each is checked
+against its rule.
+"""
+from __future__ import annotations
+
+from collections import Counter, deque
+from concurrent.futures import ProcessPoolExecutor
+import json
+import os
+from pathlib import Path
+import re
+import sys
+import unicodedata
+
+import pyarrow as pa
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+import licence_basis as lb  # noqa: E402
+
+SOURCE = "biblioteka_nauki"
+WEB, API_URL = "https://bibliotekanauki.pl/", "https://bibliotekanauki.pl/api/"
+DEPOSITOR_DATE = "2026-10-05/2026-10-06"
+DROP, KEEP = "drop", "keep"
+CREATED_BEFORE = lb.CREATED_BEFORE
+
+# --- rule texts -------------------------------------------------------------------------------------------------------
+FRONT, BACK, HEAD, TAIL = 4000, 3000, 8000, 5000  # characters searched: front matter, back matter, head and tail for the author
+CREDIT_HEAD = 2500
+R2_FRONT = {  # first FRONT characters
+    "reprint_word": r"(?i)\bprzedruk\w*|\bpierwodruk\w*|(?<![\w-])reprint(?:ed)?\b",
+    "permission": r"(?i)\b(?:reprinted|reproduced|translated|published|republished|printed)\s+(?:here\s+)?(?:with|by)\s+(?:the\s+)?(?:kind\s+)?permission"
+                  r"|\b(?:przedrukowan\w+|przetłumaczon\w+|opublikowan\w+|zamieszczon\w+|publikowan\w+|tłumaczeni\w+|wydan\w+)\s+(?:artyku\w+\s+)?(?:za|na)\s+(?:zgodą|zezwoleniem|podstawie\s+zgody)"
+                  r"|\bza\s+(?:zgodą|zezwoleniem)\s+(?:wydawcy|wydawnictwa|redakcji|właściciela\s+praw)"
+                  r"|kind\s+permission",
+    "earlier": r"(?i)\b(?:first|originally|previously|earlier)\s+(?:published|appeared)\b|\boriginally\s+appeared\b|\bpublished\s+(?:earlier|previously|originally|first)\b"
+               r"|\bpierwotnie\s+(?:opublik|ukaza|wydan)\w+|\bukaza\w+\s+się\s+(?:po\s+raz\s+pierwszy|wcześniej|pierwotnie|uprzednio)"
+               r"|\b(?:publikowan|opublikowan|drukowan)\w+\s+(?:wcześniej|uprzednio|pierwotnie)",
+}
+R2_TITLE = {  # the citation title
+    "title_translation": r"(?i)\((?:przekład|tłum\w*|translation|translated)[^)]*\)|\[(?:przekład|tłum\w*|translation)|\bprzekład\s+z\b|\btłumaczenie\s+z\b|\btranslated\s+from\b|\btranslation\s+of\b",
+    "title_reprint": r"(?i)\bprzedruk\b|\breprint\b|\(przedruk",
+}
+_NAME = r"[A-ZŁŚŻŹĆ][a-ząęółśżźćńü\-]{2,}(?:\s+[A-ZŁŚŻŹĆ][a-ząęółśżźćńü\-]{2,}){1,2}"
+R2_CREDIT = (r"(?:\bPrzekład|\bTłumaczenie|\bTranslated by|\bTranslation by|\bPrzełożył[a]?|\bTłumaczył[a]?|\bTłum\.|\bPrzeł\.|\bPrzekład z [^.]{3,40}:)\s*:?\s*("
+             + _NAME + r")\s*(?:[.\n]|$|\s(?=[A-Z0-9]))")
+R2_STATEMENT = (r"(?i)\b(?:polish\s+translation|polski\s+przekład|przekład\s+polski|tłumaczenie\s+polskie|polskie\s+tłumaczenie|translated\s+(?:from|into)"
+                r"|przetłumaczon\w+\s+(?:z|na)|tłumaczenie\s+(?:artyku|tekst)\w*|przekład\s+(?:artyku|tekst)\w*|za\s+zgodą\s+autora\s+tłumaczenia"
+                r"|tekst\s+(?:został\s+)?przełożon\w+)")
+R2 = {**{k: (re.compile(v), "front") for k, v in R2_FRONT.items()}, **{k: (re.compile(v), "title") for k, v in R2_TITLE.items()},
+      "translator_credit": (re.compile(R2_CREDIT), "credit"), "translation_statement": (re.compile(R2_STATEMENT), "credit")}
+ARR = re.compile(r"(?i)wszelkie\s+prawa\s+(?:zastrzeżone|autorskie\s+zastrzeżone)|wszystkie\s+prawa\s+zastrzeżone|all\s+rights\s+reserved|tous\s+droits\s+réservés|alle\s+rechte\s+vorbehalten")
+CONSENT = re.compile(
+    r"(?i)(?:przedrukowywanie|przedruk\w*|kopiowanie|powielanie|rozpowszechnianie|reprodukowanie|rozpowszechniania)[^.]{0,100}"
+    r"(?:bez\s+(?:pisemnej\s+|uprzedniej\s+|uprzedniego\s+)?(?:zgody|zezwolenia)|zabronion\w+|wymaga\w*\s+zgody)"
+    r"|(?:reprint\w*|reproduc\w*|copying|redistribut\w*|duplicat\w*)[^.]{0,80}(?:without\s+(?:the\s+)?(?:prior\s+)?(?:written\s+)?(?:permission|consent)|prohibited|forbidden|not\s+permitted)"
+    r"|bez\s+(?:pisemnej\s+)?zgody\s+(?:wydawcy|autora|redakcji)|zabrania\s+się\s+(?:kopiowania|powielania|przedruk)|swoboda\s+użytkownika\s+ograniczona")
+CLAUSE_AFTER_ARR = re.compile(r"(?i)nie\s+(?:może|mogą)\b|bez\s+(?:pisemnej\s+)?zgody|without\s+(?:the\s+)?(?:prior\s+)?(?:written\s+)?permission|zabronion|ograniczona")
+
+# --- decisions made by reading the text (every id is checked against its rule in decisions()) --------------------------------
+
+
+def ids(s: str) -> tuple[str, ...]:
+    return tuple(f"{SOURCE}_{i}" for i in s.split())
+
+
+HAND = {
+    # the 13 rows whose text prints a CC licence with other elements than the label (all read)
+    "printed_note": {
+        (DROP, "printed_licence_nc_or_nd"): ids("books_1035301 books_1076500 articles_2089611 articles_520828"),
+        (KEEP, "printed_sa_label_by"): ids("books_1182283 books_2036704"),
+        (KEEP, "printed_by_label_sa"): ids("books_1705635 articles_1848138"),
+        (KEEP, "translation_of_cc_original"): ids("articles_910940 articles_911982"),
+        (KEEP, "discusses_licence"): ids("articles_474574 articles_474664 articles_953975"),
+    },
+    # rows the regex families or the platform's flags nominated and whose text says the work is a reprint, a translation or an earlier publication
+    "prior_publication": {
+        (DROP, "api_flagged_reprint_translation"): ids("books_1954543 books_2139603 articles_508678 articles_1194786 articles_2154637"),
+        (DROP, "republished_by_permission"): ids("articles_346483 articles_520042 articles_699742 articles_1964616 articles_1966200 "
+                                                 "articles_520050 articles_520074 articles_1202427 articles_633657 books_1041711 articles_1374053"),
+        (DROP, "reprint_or_prior_publication"): ids(
+            "articles_371128 articles_508708 articles_511041 articles_520083 articles_534737 articles_634900 articles_782734 articles_1595585 "
+            "articles_1595639 articles_1808275 articles_1810424 articles_1936222 articles_1939790 articles_1965953 articles_2075829 articles_474667 "
+            "articles_484859 articles_486914 articles_520058 articles_520068 articles_611730 articles_643795 articles_643799 articles_666502 "
+            "articles_1202404 articles_2091081 articles_2095983 articles_2153254 articles_2054013 articles_2054042"),
+        (DROP, "translation_of_earlier_publication"): ids(
+            "articles_2141629 articles_2141775 articles_394624 articles_511176 articles_616723 articles_1373931 articles_1912267 articles_2136031 "
+            "articles_2153244 articles_646622 articles_2127589 articles_2137969 articles_1966127 articles_2058299 articles_645298 articles_1070475 articles_2158481"),
+        (DROP, "translation_title_marker"): ids("articles_699524 articles_699526 articles_699750 articles_699752 articles_783754"),
+        (KEEP, "same_author_prior_version"): ids("articles_275580 articles_1198505 articles_534891 articles_643777 articles_647385"),
+    },
+    # rows whose title and author are both absent from the first 6000 characters / the head and tail (all read)
+    "file_mismatch": {
+        (DROP, "file_is_another_work"): ids("books_1623111 articles_95765 articles_112558 articles_322929 articles_483009 articles_629493 articles_631744 "
+                                            "articles_646733 articles_646887 articles_646910 articles_646974 articles_647170 articles_694754 articles_1396194 "
+                                            "articles_1788320 articles_1834965"),
+        (KEEP, "item_found_later_in_file"): ids("articles_506975 articles_604494 articles_604538"),
+        (KEEP, "title_in_other_language"): ids("articles_604544 articles_619442 articles_620103 articles_681481 articles_695405"),
+        (KEEP, "front_matter_item"): ids("articles_694701 articles_694705"),
+        (KEEP, "text_garbled"): ids(
+            "articles_609659 articles_609697 articles_609782 articles_609876 articles_610006 articles_610073 articles_610129 articles_610157 articles_610257 "
+            "articles_610295 articles_610442 articles_610446 articles_610469 articles_610578 articles_610592 articles_610664 articles_610798 articles_611091 "
+            "articles_611109 articles_611113 articles_611138 articles_611170 articles_545065 articles_545096 articles_545192"),
+    },
+}
+# restriction hits that are not a notice about the work (a quoted source, a discussion of unauthorised copying, a notice on a questionnaire)
+NOT_A_NOTICE = ids("articles_336963 articles_417422 articles_548260 articles_617638 articles_699550 articles_2053946")
+# translations of ancient, archival or literary source texts: not screened (see the evidence file)
+SOURCE_TEXT_TRANSLATIONS = ids("articles_1806845 articles_1806823 articles_1806867 articles_2057384 articles_1194054 articles_1917278 articles_534737 articles_699650 articles_555820")
+PRIORITY = ("printed_note", "prior_publication", "file_mismatch", "restriction_notice", CREATED_BEFORE)
+REASONS = {  # decision -> {reason: what it means}
+    DROP: {
+        "printed_licence_nc_or_nd": "the text prints a NonCommercial or NoDerivatives licence; the platform's label is a CC BY or BY-SA licence",
+        "api_flagged_reprint_translation": "the platform flags the item as a reprint or a translation (`reprintPublication` or `translationPublication`)",
+        "republished_by_permission": "the text says it is a reprint or a translation published with the permission of an author or publisher",
+        "reprint_or_prior_publication": "the text says the work was published before, or is a reprint, in a place other than this platform",
+        "translation_of_earlier_publication": "the text is a translation of a work published elsewhere, stated in the text or by a translator credit",
+        "translation_title_marker": "the citation title marks the item as a translation of a third party's text",
+        "file_is_another_work": "neither the title nor any author of the description appears where the text starts, ends or is attributed; the file is a different work",
+        "restriction_notice_no_cc_note": "the front or back matter prints a restriction on copying or reproduction, and prints no CC licence of its own",
+        CREATED_BEFORE: "the `created` start year is earlier than the first year of the label's licence version (RELEASE), so the licence on the platform cannot have been the one chosen at publication",
+    },
+    KEEP: {
+        "printed_sa_label_by": "the text prints CC BY-SA; the label is CC BY (the label is the more permissive)",
+        "printed_by_label_sa": "the text prints CC BY; the label is CC BY-SA (the label is the less permissive)",
+        "translation_of_cc_original": "the printed CC licence is the licence of the original that the text translates",
+        "discusses_licence": "the text discusses licences; the printed licence is not a note about the work",
+        "same_author_prior_version": "the text is a revised or translated version of the authors' own earlier publication",
+        "item_found_later_in_file": "the title and author appear later in the file than the first 6000 characters",
+        "title_in_other_language": "the title appears in another language than the description's",
+        "front_matter_item": "the item is a list of reviewers or of abbreviations; the description names a different item of the issue",
+        "text_garbled": "the text is not readable (shifted letters or noise), so no title or author can match; a data-quality issue, not a licence issue",
+        "arr_only_no_cc_note": "the front or back matter prints 'all rights reserved' without a clause and prints no CC licence of its own",
+        "restriction_notice_beside_cc_note": "the front matter prints 'all rights reserved' or a restriction and, in the same front matter, a CC licence with the label's elements",
+        "not_a_notice_on_the_work": "a phrase found by the rule is a quoted source, a discussion or a notice on something else",
+    },
+}
+REASON_TEXT = {reason: text for group in REASONS.values() for reason, text in group.items()}
+
+
+# --- text rules --------------------------------------------------------------------------------------------------------
+def fold(s: str) -> str:
+    s = unicodedata.normalize("NFKD", s.casefold().replace("ł", "l"))
+    return "".join(c for c in s if not unicodedata.combining(c))
+
+
+def words(s: str, n: int = 4) -> list[str]:
+    return [w for w in re.findall(r"[a-z0-9]+", fold(s)) if len(w) >= n]
+
+
+def parts_of(citation: str) -> tuple[str, str]:
+    """(author field, title field) of 'Autor | Rok | Tytuł[ | Wydawca]'."""
+    parts = citation.split(" | ")
+    return parts[0], parts[2] if len(parts) > 2 else ""
+
+
+def file_mismatch(text: str, citation: str) -> bool:
+    """True when no title word (>=4 letters) is in the first 6000 characters and no author surname (first 5 letters) is in the head or tail."""
+    author, title = parts_of(citation)
+    title_words = words(title)
+    surnames = [w[0][:5] for a in author.split(";") if a.strip() and (w := words(a.split()[-1], 3))]
+    if not title_words or not surnames:
+        return False
+    head = set(words(text[:6000]))
+    area = fold(text[:HEAD] + " " + text[-TAIL:])
+    return not any(w in head for w in title_words) and not any(s in area for s in surnames)
+
+
+def restriction(text: str) -> str | None:
+    """'clause' (a restriction on copying or reproduction, or 'all rights reserved' followed by one), 'arr_only', or None; front and back matter."""
+    kind = None
+    for segment in (text[:FRONT], text[-BACK:]):
+        arr = ARR.search(segment)
+        if CONSENT.search(segment) or (arr and CLAUSE_AFTER_ARR.search(segment[arr.end(): arr.end() + 300])):
+            return "clause"
+        kind = "arr_only" if arr else kind
+    return kind
+
+
+def prior_publication_hits(text: str, citation: str) -> tuple[str, ...]:
+    front, title = text[:FRONT], parts_of(citation)[1]
+    area = {"front": front, "title": title, "credit": text[:CREDIT_HEAD]}
+    return tuple(name for name, (pattern, where) in R2.items() if pattern.search(area[where]))
+
+
+BATCH, COLUMNS = 200, ["id", "text", "license", "created", "token_count", "added", "attribution"]
+
+
+def scan_batch(rows: list[tuple]) -> list[dict]:
+    recs = []
+    for row_id, text, label, created, tokens, added, citation in rows:
+        kind, _ = lb.note_vs_label(text, label)
+        citation = citation or ""
+        recs.append({"id": row_id, "chars": len(text), "tokens": tokens, "label": label, "year": lb.created_year(created), "added": added,
+                     "note": kind, "mismatch": file_mismatch(text, citation), "restriction": restriction(text),
+                     "prior": prior_publication_hits(text, citation)})
+    return recs
+
+
+def scan(table: pa.Table, workers: int = min(8, os.cpu_count() or 1)) -> list[dict]:
+    """One small record per row of `table` (columns COLUMNS, `attribution` = the full citation), in row order; the texts are not kept.
+    The batches go to a pool."""
+    out, pending = [], deque()
+    with ProcessPoolExecutor(workers) as pool:
+        for batch in table.select(COLUMNS).to_batches(max_chunksize=BATCH):
+            pending.append(pool.submit(scan_batch, list(zip(*(column.to_pylist() for column in batch.columns)))))
+            if len(pending) >= 2 * workers:
+                out += pending.popleft().result()
+        out += [r for future in pending for r in future.result()]
+    return out
+
+
+# --- decisions ---------------------------------------------------------------------------------------------------------
+def decisions(recs: list[dict], flagged: set[str]) -> dict[str, dict[str, tuple[str, str]]]:
+    """{rule: {id: (decision, reason)}}. Raises when a hand-decided id is not nominated by its rule, or a rule nominates an id nobody decided."""
+    by_id = {r["id"]: r for r in recs}
+    out: dict[str, dict[str, tuple[str, str]]] = {}
+    for rule, groups in HAND.items():
+        out[rule] = {i: key for key, group in groups.items() for i in group}
+        if sum(len(g) for g in groups.values()) != len(out[rule]):
+            raise ValueError(f"{rule}: an id has two decisions")
+        missing = set(out[rule]) - by_id.keys()
+        if missing:
+            raise ValueError(f"{rule}: ids not in the shard: {sorted(missing)}")
+    nominated = {"printed_note": {r["id"] for r in recs if r["note"] == "conflict"},
+                 "file_mismatch": {r["id"] for r in recs if r["mismatch"]},
+                 "prior_publication": {r["id"] for r in recs if r["prior"]} | flagged}
+    for rule, ids_ in nominated.items():
+        decided = set(out[rule])
+        if (rule == "prior_publication" and decided - ids_) or (rule != "prior_publication" and decided != ids_):
+            raise ValueError(f"{rule}: decided {len(decided)}, nominated {len(ids_)}, differing {sorted(decided ^ ids_)[:10]}")
+    out["restriction_notice"] = {r["id"]: restriction_decision(r) for r in recs if r["restriction"]}
+    if not set(NOT_A_NOTICE) <= set(out["restriction_notice"]):
+        raise ValueError("a hand-listed non-notice is no longer a hit of the restriction rule")
+    out[CREATED_BEFORE] = {r["id"]: (DROP, CREATED_BEFORE) for r in recs if r["year"] < lb.release_year(r["label"])}
+    return out
+
+
+def restriction_decision(rec: dict) -> tuple[str, str]:
+    return ((KEEP, "not_a_notice_on_the_work") if rec["id"] in NOT_A_NOTICE else
+            (KEEP, "restriction_notice_beside_cc_note") if rec["note"] == "file_note" else
+            (DROP, "restriction_notice_no_cc_note") if rec["restriction"] == "clause" else (KEEP, "arr_only_no_cc_note"))
+
+
+def final_reasons(by_rule: dict[str, dict[str, tuple[str, str]]]) -> dict[str, tuple[str, str, str]]:
+    """{id: (decision, reason, rule)}: the first `drop` in PRIORITY order, else the first `keep`."""
+    final: dict[str, tuple[str, str, str]] = {}
+    for rule in PRIORITY:
+        for row_id, (decision, reason) in by_rule[rule].items():
+            if row_id not in final or (final[row_id][0] == KEEP and decision == DROP):
+                final[row_id] = (decision, reason, rule)
+    return final
+
+
+def proposed_review(final: dict[str, tuple[str, str, str]]) -> dict[str, tuple[str, str]]:
+    """{id: (decision, reason)}: the table the rules give, to be equal to the pinned one."""
+    return {i: (d, r) for i, (d, r, _) in final.items()}
+
+
+def review_csv(final: dict[str, tuple[str, str, str]]) -> str:
+    return "id,decision,reason\n" + "".join(f"{i},{d},{r}\n" for i, (d, r) in sorted(proposed_review(final).items()))
+
+
+# --- sidecar ------------------------------------------------------------------------------------------------------------
+def read_sidecar(path: Path) -> list[dict]:
+    return [json.loads(line) for line in path.read_bytes().decode("utf-8").split("\n") if line]
+
+
+def sidecar_bytes(lines: list[dict]) -> bytes:
+    """Default `json.dumps` escaping: a citation may contain U+2028/U+2029, which must not read as a line break."""
+    return "".join(json.dumps(line) + "\n" for line in lines).encode("utf-8")
+
+
+def item_url(row_id: str, api: bool) -> str:
+    kind, number = row_id.removeprefix(f"{SOURCE}_").split("_")
+    if kind not in ("articles", "books", "chapters") or not number.isdigit():
+        raise ValueError(row_id)
+    return f"{API_URL if api else WEB}{kind}/{number}"
+
+
+def basis_of(rec: dict) -> tuple[str, str, str]:
+    """(code, url, date) of one row."""
+    if rec["note"] == "file_note":
+        return "file_note", item_url(rec["id"], False), rec["added"]
+    return "depositor", item_url(rec["id"], True), DEPOSITOR_DATE
+
+
+def attribution_lines(recs: list[dict], citations: list[str]) -> list[dict]:
+    """The sidecar's lines in row order: id, full citation and the basis fields."""
+    return [lb.merge_basis({"id": r["id"], "attribution": c or ""}, *basis_of(r)) for r, c in zip(recs, citations, strict=True)]
+
+
+def measure(recs: list[dict]) -> dict[str, int]:
+    return {"rows": len(recs), "characters": sum(r["chars"] for r in recs), "tokens": sum(r["tokens"] for r in recs)}
+
+
+NOMINATED = {
+    "printed_note": "licence_basis.note_vs_label(...) == 'conflict'",
+    "prior_publication": "any regex family of R2 in the front matter or the citation title, or an API flag; "
+                         "the review lists only the rows whose reading confirmed a reprint, a translation or an earlier publication",
+    "file_mismatch": "file_mismatch(text, citation)",
+    "restriction_notice": "restriction(text) is not None",
+    CREATED_BEFORE: "the `created` start year is earlier than RELEASE[label]",
+}
+
+
+def evidence(recs: list[dict], by_rule: dict[str, dict[str, tuple[str, str]]], final: dict[str, tuple[str, str, str]],
+             flags: dict[str, list[str]], pinned: dict) -> dict:
+    """The evidence file. `recs` are the rows before the review (the screens were measured on them); the counts by basis describe the rows
+    that stay. `pinned` is what the build knows: {"review": {"file", "sha256"}, "input": {...}, "kept": {...}}."""
+    by_id = {r["id"]: r for r in recs}
+    shipped = [r for r in recs if final.get(r["id"], (KEEP,))[0] != DROP]
+    dropped_ids = {i for i, v in final.items() if v[0] == DROP}
+    basis = [basis_of(r) for r in shipped]
+    counts = Counter(code for code, _, _ in basis)
+    rule_rows = {rule: {reason: measure([by_id[i] for i, (_, rsn) in group.items() if rsn == reason]) for reason in sorted({rsn for _, rsn in group.values()})}
+                 for rule, group in by_rule.items()}
+    review_rows = {reason: measure([by_id[i] for i, (_, rsn, _) in final.items() if rsn == reason]) for reason in sorted({v[1] for v in final.values()})}
+    decided = {decision: measure([by_id[i] for i, v in final.items() if v[0] == decision]) for decision in (DROP, KEEP)}
+    proxy = set(by_rule[CREATED_BEFORE])
+    earlier = {i: [by_rule[rule][i] for rule in PRIORITY if rule != CREATED_BEFORE and i in by_rule[rule]] for i in proxy}  # what the other rules decided
+    dropped_before = Counter(final[i][1] for i in proxy if any(d == DROP for d, _ in earlier[i]))  # these keep the reason of their first drop
+    flipped = Counter(earlier[i][0][1] for i in proxy if earlier[i] and all(d == KEEP for d, _ in earlier[i]))  # kept by the others, dropped here
+    result = {
+        "source": SOURCE, "issue": "slayerlabs/polish-dynaword-v2#111", "codes": list(lb.CODES), "counts": {c: counts.get(c, 0) for c in lb.CODES},
+        "dates": {"file_note": "the row's `added` date", "depositor": DEPOSITOR_DATE}, "added_dates": sorted({r["added"] for r in shipped}),
+        "by_label": {label: {c: sum(1 for r, b in zip(shipped, basis) if r["label"] == label and b[0] == c) for c in lb.CODES}
+                     for label in sorted({r["label"] for r in shipped})},
+        "by_code": {c: measure([r for r, b in zip(shipped, basis) if b[0] == c]) for c in lb.CODES if counts.get(c)},
+        "urls": {"file_note": f"{WEB}{{articles|books|chapters}}/{{n}}", "depositor": f"{API_URL}{{articles|books|chapters}}/{{n}}"},
+        "rule": "file_note: licence_basis.note_vs_label(text, label) is 'file_note', i.e. a CC note in the front or back matter, not about a photo or a quoted source, "
+                "with the label's elements; depositor: every other row, whose label is the platform's licence object for the item",
+        "hand_check": {
+            "file_note": "seeded sample of 60 of the file_note rows read in context: 60 genuine notes of the work's own licence "
+                         "(one carries a general 'unless stated otherwise' note of the publishing university)",
+            "not_measured": "rows with a licence printed in words or a form the parser does not read (false negatives of file_note) were not counted",
+        },
+        "platform_check": {"retrieved": "2026-10-05..2026-10-06", "rows_asked": 42068, "answered_200": 42056, "http404": 12,
+                           "note": "the 12 http404 rows are withheld, so no shipped row has `none`; see biblioteka_nauki.license-evidence.json"},
+        "publisher_check": {"done": False, "note": "no journal or publisher page was read; the issue allows `publisher` as a second basis"},
+        "journal_adoption": {"obtainable": False,
+                             "reason": "GET /api/journals/{id} returns the journal's current licence only, the shipped rows carry no journal key, and fetching every item takes about 26 hours at the polite rate",
+                             "consequence": "an issue from before its journal adopted CC may remain wherever the publication year is not earlier than the licence version",
+                             "proxy": CREATED_BEFORE},
+        CREATED_BEFORE: {
+            "rule": "the `created` start year is earlier than the first year of the label's licence version; the row is dropped",
+            "release_year": lb.RELEASE, "note": "a lower bound: the years are those of the generic licence texts (the Polish port may be later, which would add rows), "
+                                             "and the platform shows the licence it has today, which may be later than the issue",
+            **measure([by_id[i] for i in proxy]), "by_label": dict(sorted(Counter(by_id[i]["label"] for i in proxy).items())),
+            "precedence": "a row some other rule dropped keeps that rule's reason; a row only kept by another rule is dropped here",
+            "overlap": {"already_dropped_by_another_rule": dict(sorted(dropped_before.items())), "flipped_from_keep": dict(sorted(flipped.items())),
+                        "not_otherwise_in_review": sum(1 for i in proxy if not earlier[i]),
+                        "dropped_with_this_reason": review_rows.get(CREATED_BEFORE, {}).get("rows", 0)},
+            "hand_check": "seeded sample of 100 of these rows: in 90 the `created` year is printed in the first 8000 or last 5000 characters; "
+                          "in the other 10 the text cites no later year than `created`",
+        },
+        "rules": {rule: {"nominated": NOMINATED[rule], "by_reason": rule_rows[rule]} for rule in PRIORITY},
+        "regexes": {"R2_FRONT": R2_FRONT, "R2_TITLE": R2_TITLE, "R2_CREDIT": R2_CREDIT, "R2_STATEMENT": R2_STATEMENT, "ARR": ARR.pattern,
+                    "CONSENT": CONSENT.pattern, "CLAUSE_AFTER_ARR": CLAUSE_AFTER_ARR.pattern},
+        "nominated_rows": {
+            "prior_publication": {name: sum(1 for r in recs if name in r["prior"]) for name in R2},
+            "prior_publication_any": sum(1 for r in recs if r["prior"] or r["id"] in flags),
+            "prior_publication_in_review": len(by_rule["prior_publication"]),
+            "file_mismatch": sum(r["mismatch"] for r in recs), "printed_note": sum(r["note"] == "conflict" for r in recs),
+            "restriction_notice": Counter(f"{r['restriction']}/{r['note']}" for r in recs if r["restriction"]),
+        },
+        "hand_read": {
+            "printed_note": "all 13 rows read",
+            "file_mismatch": "all 51 rows read; the looser sets (title only absent: 476 rows, author only absent: 458, the 51 excluded) were sampled, 30 of each: "
+                             "0 of the 60 were a different work (other language, encoding or front matter)",
+            "prior_publication": "every row with a hit of the tight families (reprint words in the front matter, permission, earlier publication, title markers, "
+                                 "translator credit and translation statement) was read in context; the broad translator-word family (1,326 rows, mostly footnotes) was not. "
+                                 "Rows read and not confirmed (prior_publication_any minus prior_publication_in_review) are not in the review",
+            "restriction_notice": "all 120 hits read in context; 6 of the 110 outside file_note rows are not a notice on the work",
+        },
+        "not_screened": {"translations_of_source_texts": {
+            **measure([r for r in shipped if r["id"] in SOURCE_TEXT_TRANSLATIONS]), "ids": [i for i in SOURCE_TEXT_TRANSLATIONS if i not in dropped_ids],
+            "dropped_by_review": {i: final[i][1] for i in SOURCE_TEXT_TRANSLATIONS if i in dropped_ids},
+            "note": "translations of ancient, archival or literary texts by the item's author; the original is not a rights-held work in the sense of the rule. "
+                    "One of the 9 is in the review under a prior-publication reason and is dropped (`dropped_by_review`)"}},
+        "api_flags": {i: f for i, f in sorted(flags.items())},
+        "overlaps": {i: sorted({by_rule[rule][i][1] for rule in PRIORITY if i in by_rule[rule]})
+                     for i in sorted(final) if sum(i in by_rule[rule] for rule in PRIORITY) > 1},
+        "review": {**pinned["review"], "rows": len(final), "reasons": {d: {k: v for k, v in group.items() if k in review_rows} for d, group in REASONS.items()},
+                   "rule_order": list(PRIORITY), "by_reason": review_rows, "decided": decided, "source": measure(recs), "shipped": measure(shipped),
+                   "note": "drops decided by the maintainer on 2026-10-20 (v2#111); the table lists every row a rule nominated, `drop` or `keep`, and nothing else",
+                   "kept": pinned["kept"]},
+        "input": pinned["input"],
+    }
+    return result

src/sources.py

@@ -990,7 +990,11 @@ SOURCES = {
                      "Biblioteka Nauki API gave for that record on 2026-10-05/06 "
                      "(CC BY 2.0, 3.0, 3.0 PL, 4.0; CC BY-SA 3.0, 3.0 PL, 4.0), checked "
                      "against the licence URL and icon. The API licence objects are "
-                     "committed as biblioteka_nauki.license-api.json.",
+                     "committed as biblioteka_nauki.license-api.json. Each attribution "
+                     "sidecar line also gives the basis: the platform's licence field "
+                     "for 35,186 rows (depositor), a CC licence printed in the text for "
+                     "2,657 (file_note); no journal or publisher page was read "
+                     "(v2#111).",
         "upstream": "https://bibliotekanauki.pl/",
         "provenance": "Text from the SpeakLeash redistribution; licence and attribution "
                       "recovered per document from the Biblioteka Nauki API (Hub PR 11); "
@@ -998,7 +1002,8 @@ SOURCES = {
                       "bibliotekanauki.pl/api/{type}/{id} "
                       "(recover_license_versions.py, recover_attribution.py); rows the API "
                       "did not resolve to an allowlisted CC BY or CC BY-SA licence are "
-                      "withheld by clean_biblioteka_nauki.py.",
+                      "withheld by clean_biblioteka_nauki.py, which then drops the rows "
+                      "of a pinned review table (biblioteka_nauki.review.csv, v2#111).",
         "legal_note": "The `license` column holds the per-record version, not a single "
                       "CC BY 4.0 / CC BY-SA 4.0 label: CC BY-SA rows (about one third) are "
                       "share-alike under their own version (3.0, 3.0 PL or 4.0). Dropped: "
@@ -1006,9 +1011,18 @@ SOURCES = {
                       "v2#52), 12 rows the API no longer serves (HTTP 404), 56 rows whose own "
                       "text prints a NonCommercial or NoDerivatives licence and 15 rows whose "
                       "text says it is reprinted or translated by permission of a publisher "
-                      "(maintainer decision 2026-10-06, v2#57). About 120 texts contain the "
-                      "phrase \"all rights reserved\" although their API licence is CC; that is "
-                      "not resolved here. How the text layer was assembled from the SpeakLeash "
+                      "(maintainer decision 2026-10-06, v2#57). Dropped after review "
+                      "(maintainer decisions 2026-10-20, v2#111): 4,142 rows, of which 3,957 "
+                      "because the `created` year is earlier than the first year of the "
+                      "label's licence version (2.0: 2004; 3.0 and 3.0 PL: 2007; 4.0: 2013) "
+                      "and 185 because the text prints a NonCommercial or NoDerivatives "
+                      "licence, is a reprint, a translation or another work, or prints a "
+                      "restriction on copying and no CC licence of its own. Journal adoption "
+                      "years could not be obtained, so issues from before a journal adopted "
+                      "Creative Commons may remain where the publication year is not earlier "
+                      "than the licence version. 16 texts contain the phrase \"all rights "
+                      "reserved\" as written although their API licence is CC; that is not "
+                      "resolved here. How the text layer was assembled from the SpeakLeash "
                       "blob is not re-verified: the assembly script was not committed.",
         "domain": "academic",
         "created": "unknown",

src/test_biblioteka_nauki_contract.py

@@ -1,5 +1,6 @@
-"""Contract checks for biblioteka_nauki: public-domain drop, per-record licence versions and the withheld rows
-(src/clean_biblioteka_nauki.py, data/biblioteka_nauki/recover_license_versions.py)."""
+"""Contract checks for biblioteka_nauki: public-domain drop, per-record licence versions, the withheld rows and the reviewed drops
+(src/clean_biblioteka_nauki.py, data/biblioteka_nauki/recover_license_versions.py). The review and the rules are tested in
+src/test_licence_basis_biblioteka_nauki.py."""
 
 import hashlib
 import importlib.util
@@ -17,8 +18,10 @@ import pytest
 sys.path.insert(0, str(Path(__file__).resolve().parent))
 
 from clean_biblioteka_nauki import (
-    API_OVERRIDES, ATTRIBUTION_SEP, DATA, KEEP, SIDECAR, TEXT_NC_ND, TEXT_REPRINT, build, content_digest, filter_table,
-    license_label, relabel, split_attribution, split_author, withhold_listed)
+    API_OVERRIDES, ATTRIBUTION_SEP, CLEANED_CONTENT_SHA256, DATA, KEEP, LICENSE_API, TEXT_NC_ND, TEXT_REPRINT, build, check_review,
+    clean_table, content_digest, filter_table, license_label, read_review, relabel, rows_digest, split_attribution, split_author,
+    withhold_listed)
+import licence_basis_biblioteka_nauki as lbn
 from normalize_schema import SCHEMA
 from sources import SOURCES
 
@@ -59,8 +62,8 @@ def stats():
 
 
 @pytest.fixture(scope="module")
-def sidecar():
-    return json.loads(SIDECAR.read_text(encoding="utf-8"))
+def api():
+    return json.loads(LICENSE_API.read_text(encoding="utf-8"))
 
 
 def test_shard_has_no_public_domain_rows_and_matches_stats(stats):
@@ -80,10 +83,11 @@ def test_shard_has_no_public_domain_rows_and_matches_stats(stats):
     assert pc.min(table.column("token_count")).as_py() > 0
     authors = table.column("author").to_pylist()
     assert all(isinstance(a, str) for a in authors)
-    assert sum(1 for a in authors if not a) == 27  # the `. .` placeholder citations
+    assert sum(1 for a in authors if not a) == 25  # the `. .` placeholder citations (27 before the year rule dropped 2)
     drops = ("drop_short", "drop_lang", "drop_dup", "drop_ocr", "drop_rights",
-             "drop_license_unverified", "drop_text_nc_nd", "drop_text_reprint")
+             "drop_license_unverified", "drop_text_nc_nd", "drop_text_reprint", "drop_review")
     assert stats["read"] - sum(stats[k] for k in drops) == stats["kept"]
+    assert stats["drop_review"] == sum(stats["drop_review_by_reason"].values())
     assert stats["drop_rights"] == 3
     assert stats["drop_license_unverified"] + stats["drop_text_nc_nd"] + stats["drop_text_reprint"] == len(stats["withheld"])
 
@@ -114,43 +118,52 @@ def test_maintainer_withholds_and_relabel_of_2026_10_06(stats):
     assert (stats["drop_text_nc_nd"], stats["drop_text_reprint"]) == (56, 15)
     assert API_OVERRIDES == {RELABELLED_ID: "CC-BY-SA-4.0"}
     assert labels[RELABELLED_ID] == "CC-BY-SA-4.0" and RELABELLED_ID not in stats["withheld"]
-    assert stats["kept"] == 42055 + 1 - 71
+    assert stats["kept"] + stats["drop_review"] == 42055 + 1 - 71  # the rows before the reviewed drops
 
 
-def test_shard_labels_are_the_api_licences_in_the_sidecar(stats, sidecar):
-    """Every row's label is the one its API licence gives, and every shipped or withheld id is in the sidecar."""
+def test_shard_labels_are_the_api_licences_in_the_sidecar(stats, api):
+    """Every row's label is the one its API licence gives, and every shipped, withheld or review-dropped id is in the API file."""
     table = pq.read_table(DATA / "biblioteka_nauki.parquet", columns=["id", "license"])
     ids = table.column("id").to_pylist()
     for row_id, label in zip(ids, table.column("license").to_pylist()):
-        lic = sidecar["licenses"][str(sidecar["rows"][row_id])]
+        lic = api["licenses"][str(api["rows"][row_id])]
         assert label == license_label(lic, lic["iconId"]), row_id
-    assert not set(ids) & set(stats["withheld"])
-    assert set(ids) | set(stats["withheld"]) == set(sidecar["rows"]) | set(sidecar["unresolved"])
-    assert sidecar["rows_total"] == len(sidecar["rows"]) + len(sidecar["unresolved"]) == len(ids) + len(stats["withheld"])
+    review_dropped = {i for i, (decision, _) in read_review().items() if decision == lbn.DROP}
+    assert len(review_dropped) == stats["drop_review"]
+    assert not set(ids) & set(stats["withheld"]) and not set(ids) & review_dropped and not set(stats["withheld"]) & review_dropped
+    assert set(ids) | set(stats["withheld"]) | review_dropped == set(api["rows"]) | set(api["unresolved"])
+    assert api["rows_total"] == len(api["rows"]) + len(api["unresolved"]) == len(ids) + len(stats["withheld"]) + len(review_dropped)
 
 
-def test_evidence_file_matches_sidecar_and_stats(stats, sidecar):
+def test_evidence_file_matches_sidecar_and_stats(stats, api):
+    """The file records the state of Hub PR 81 (before the reviewed drops of v2#111); the checks below hold for that state."""
     evidence = json.loads((DATA / "biblioteka_nauki.license-evidence.json").read_text(encoding="utf-8"))
-    assert evidence["sidecar_sha256"] == hashlib.sha256(SIDECAR.read_bytes()).hexdigest()
-    assert evidence["retrieved"] == sidecar["retrieved"]
+    assert evidence["sidecar_sha256"] == hashlib.sha256(LICENSE_API.read_bytes()).hexdigest()
+    assert evidence["retrieved"] == api["retrieved"]
     by_id = {str(row["api_license_id"]): row for row in evidence["api_licenses"]}
-    assert set(by_id) == set(sidecar["licenses"])
-    rows_per_license = Counter(sidecar["rows"].values())
-    for lid, lic in sidecar["licenses"].items():
+    assert set(by_id) == set(api["licenses"])
+    rows_per_license = Counter(api["rows"].values())
+    for lid, lic in api["licenses"].items():
         row = by_id[lid]
         assert (row["nameEn"], row["urlEn"]) == (lic["nameEn"], lic["urlEn"])
         assert row["label"] == license_label(lic, lic["iconId"])
         assert row["api_rows"] == rows_per_license[int(lid)]
-        assert row["shipped"] == stats["licenses"].get(row["label"], 0)
+        assert stats["licenses"].get(row["label"], 0) <= row["shipped"]  # the reviewed drops only remove rows
+    assert sum(row["shipped"] for row in evidence["api_licenses"]) == stats["kept"] + stats["drop_review"] == 41985
     assert evidence["withheld"] == len(stats["withheld"])
-    assert evidence["flagged"] == Counter(flag for flags in sidecar["flagged"].values() for flag in flags)
-    assert evidence["unchanged_vs_pr62"]["content_sha256"] == stats["content_sha256"]
+    assert evidence["flagged"] == Counter(flag for flags in api["flagged"].values() for flag in flags)
+    assert evidence["unchanged_vs_pr62"]["content_sha256"] == CLEANED_CONTENT_SHA256
+    assert "review.csv" in evidence["after_the_review_of_2026_10_20"]
 
 
-def test_shard_text_and_ids_match_the_recorded_digest(stats):
-    """Text and ids are what PR 62 shipped: stats['content_sha256'] was equal to the PR 62 shard's digest
-    (evidence: unchanged_vs_pr62), and the shard on disk still hashes to it."""
-    assert content_digest(DATA / "biblioteka_nauki.parquet") == stats["content_sha256"]
+def test_shard_text_and_ids_match_the_recorded_digests(stats):
+    """The shard on disk hashes to the digest in the stats, and every column of every row to the one in the evidence file."""
+    path = DATA / "biblioteka_nauki.parquet"
+    assert content_digest(path) == stats["content_sha256"]
+    evidence = json.loads((DATA / "biblioteka_nauki.licence-basis.json").read_text(encoding="utf-8"))
+    assert evidence["review"]["kept"] == {**evidence["review"]["kept"], "rows": stats["kept"], "rows_sha256": rows_digest(path)}
+    assert evidence["input"]["rows_before_review_content_sha256"] == CLEANED_CONTENT_SHA256
+    assert evidence["input"]["rows_before_review"] == stats["kept"] + stats["drop_review"]
 
 
 def test_content_digest_sees_text_ids_and_order_but_not_other_columns(tmp_path):
@@ -167,6 +180,62 @@ def test_content_digest_sees_text_ids_and_order_but_not_other_columns(tmp_path):
     assert digest("f.parquet", ["x", "y", "w"], ["tx", "ty", "tw"], skip=frozenset({"w"})) == base
 
 
+def test_rows_digest_sees_every_column_and_the_row_order(tmp_path):
+    columns = {"id": ["x", "y"], "text": ["tx", "ty"], "license": ["CC-BY-4.0", "CC-BY-4.0"]}
+    base = rows_digest(pa.table(columns))
+    assert rows_digest(pa.table({**columns, "license": ["CC-BY-4.0", "CC-BY-SA-4.0"]})) != base
+    assert rows_digest(pa.table({**columns, "text": ["tx", "tY"]})) != base
+    assert rows_digest(pa.table({k: v[::-1] for k, v in columns.items()})) != base
+    assert rows_digest(pa.table({k: v + ["w"] for k, v in columns.items()}), skip=frozenset({"w"})) == base
+    path = tmp_path / "a.parquet"
+    pq.write_table(pa.table(columns), path)
+    assert rows_digest(path) == base  # a file and its table digest alike
+    assert content_digest(path) == content_digest(pa.table(columns))
+
+
+def test_clean_table_counts_what_each_step_takes_and_lists_the_withheld():
+    table = pa.table({"id": ["a", "b", "c", "d", "e", "f"], "text": ["ta", "tb", "tc", "td", "te", "tf"],
+                      "license": ["cc-by", "cc-by-sa", "public-domain", "cc-by", "cc-by", "cc-by"]})
+    api = {"licenses": {"1": BY_40, "2": BYSA_40}, "rows": {"a": 1, "b": 2, "d": 1, "e": 1}, "unresolved": {"f": "http404"}}
+    kept, counts, withheld = clean_table(table, api, overrides={}, nc_nd={"d": "NC"}, reprint={"e": "reprint"})
+    assert kept.column("id").to_pylist() == ["a", "b"]
+    assert kept.column("license").to_pylist() == ["CC-BY-4.0", "CC-BY-SA-4.0"]
+    assert counts == {"drop_rights": 1, "drop_license_unverified": 1, "drop_text_nc_nd": 1, "drop_text_reprint": 1}
+    assert withheld == {"f": "API: http404", "d": "NC", "e": "reprint"}
+    with pytest.raises(SystemExit, match="listed ids not reached"):
+        clean_table(table, api, overrides={}, nc_nd={"c": "already dropped as public domain"}, reprint={})
+
+
+def test_the_pinned_review_refuses_a_changed_table(tmp_path):
+    review = read_review()
+    assert len(review) == 4205 and Counter(decision for decision, _ in review.values()) == {lbn.DROP: 4142, lbn.KEEP: 63}
+    altered = tmp_path / "biblioteka_nauki.review.csv"
+    altered.write_bytes((DATA / "biblioteka_nauki.review.csv").read_bytes() + b"biblioteka_nauki_articles_1,drop,text_garbled\n")
+    with pytest.raises(SystemExit):
+        read_review(altered)  # changed after it was pinned
+
+
+def test_check_review_refuses_a_review_the_rules_do_not_give():
+    final = {"a": (lbn.DROP, "file_is_another_work", "file_mismatch"), "b": (lbn.KEEP, "text_garbled", "file_mismatch")}
+    proposed = lbn.proposed_review(final)
+    assert proposed == {"a": (lbn.DROP, "file_is_another_work"), "b": (lbn.KEEP, "text_garbled")}
+    check_review(dict(proposed), final)
+    for review in ({**proposed, "a": (lbn.KEEP, "text_garbled")},  # a decision changed
+                   {**proposed, "c": (lbn.DROP, "file_is_another_work")},  # a row no rule nominates
+                   {"a": proposed["a"]}):  # a nominated row without a decision
+        with pytest.raises(SystemExit, match="disagree"):
+            check_review(review, final)
+
+
+def test_kept_rows_are_the_rows_before_the_review_minus_the_dropped(stats):
+    """Every column of every kept row hashes to the digest the build recorded from the rows before the review."""
+    path = DATA / "biblioteka_nauki.parquet"
+    evidence = json.loads((DATA / "biblioteka_nauki.licence-basis.json").read_text(encoding="utf-8"))
+    dropped = {i for i, (decision, _) in read_review().items() if decision == lbn.DROP}
+    ids = pq.read_table(path, columns=["id"]).column("id").to_pylist()
+    assert not set(ids) & dropped and len(ids) == stats["kept"]
+    assert rows_digest(path) == evidence["review"]["kept"]["rows_sha256"]
+
 
 def test_build_fails_closed_on_an_unpinned_input(tmp_path):
     fake = tmp_path / "biblioteka_nauki.parquet"
@@ -191,6 +260,13 @@ def test_datasheet_counts_match_stats(stats):
     for name, count in classes.items():
         assert f"| {name} | {count} |" in card, name
     assert f"read {stats['read']:,} → kept {stats['kept']:,}" in card
+    assert f"(`src/clean_biblioteka_nauki.py`, polish-dynaword-v2#111): **{stats['drop_review']:,}**" in card
+    for reason, count in stats["drop_review_by_reason"].items():
+        assert f"| {reason} | {count:,} |" in card, reason
+    basis = Counter(json.loads(line)["licence_basis"] for line in (DATA / "biblioteka_nauki.attribution.jsonl").read_text(encoding="utf-8").splitlines())
+    for code, count in basis.items():
+        assert f"| `{code}` | {count:,} |" in card, code
+    assert "Journal adoption years could not be obtained" in card and "may therefore remain" in card
     assert "| Public Domain |" not in card
     assert PROVENANCE in " ".join(card.lower().split())
     assert "direct rebuild" not in card.lower()
@@ -410,21 +486,17 @@ def test_split_author_takes_the_first_citation_field():
     assert split_author("Jolanta Kowol 1 | 2017 | Tytuł") == "Jolanta Kowol"
 
 
-def test_split_attribution_moves_the_citation_to_the_sidecar_and_keeps_the_author(tmp_path):
+def test_split_attribution_replaces_the_citation_by_its_author_in_the_canonical_columns():
     table = pa.table({
-        "id": ["a", "b"], "text": ["ta", "tb"], "source": ["biblioteka_nauki"] * 2,
-        "added": ["2026-01-01"] * 2, "created": [""] * 2, "token_count": [1, 2],
-        "license": ["CC-BY-4.0"] * 2,
-        "attribution": ["Jan Kowalski | 2020 | Tytuł | Wydawca", "Anna Nowak | 2021 | Inna"],
+        "id": ["a", "b", "c"], "text": ["ta", "tb", "tc"], "source": ["biblioteka_nauki"] * 3,
+        "added": ["2026-01-01"] * 3, "created": [""] * 3, "token_count": [1, 2, 3],
+        "license": ["CC-BY-4.0"] * 3,
+        "attribution": ["Jan Kowalski | 2020 | Tytuł | Wydawca", "Anna Nowak | 2021 | Inna", ". . | 2015 | Noty o autorach"],
     })
-    sidecar = tmp_path / "biblioteka_nauki.attribution.jsonl"
 
-    out = split_attribution(table, sidecar)
+    out = split_attribution(table)
 
     assert out.schema.names == SCHEMA.names
-    assert out.column("author").to_pylist() == ["Jan Kowalski", "Anna Nowak"]
-    lines = [json.loads(line) for line in sidecar.read_text(encoding="utf-8").splitlines()]
-    assert lines == [
-        {"id": "a", "attribution": "Jan Kowalski | 2020 | Tytuł | Wydawca"},
-        {"id": "b", "attribution": "Anna Nowak | 2021 | Inna"},
-    ]
+    assert out.column("author").to_pylist() == ["Jan Kowalski", "Anna Nowak", ""]
+    for name in ("id", "text", "license", "token_count"):
+        assert out.column(name).to_pylist() == table.column(name).to_pylist()

src/test_biblioteka_nauki_overlap.py

@@ -6,12 +6,12 @@ import sys
 import types
 from pathlib import Path
 
-import pyarrow as pa
 import pytest
 
 from biblioteka_nauki_overlap import (
     SIDECAR, citation_title, fetch_attribution_targets, normalize_title, read_attribution_targets)
-from clean_biblioteka_nauki import split_attribution
+from licence_basis import merge_basis
+from licence_basis_biblioteka_nauki import sidecar_bytes as write_sidecar
 
 SRC = Path(__file__).resolve().parent
 REPO = "SlayerLab/polish-dynaword"
@@ -24,16 +24,11 @@ CITATIONS = {
 
 
 @pytest.fixture
-def sidecar_bytes(tmp_path):
-    """The sidecar as clean_biblioteka_nauki writes it, so a change to the writer breaks the reader's test."""
-    n = len(CITATIONS)
-    table = pa.table({
-        "id": list(CITATIONS), "text": ["t"] * n, "source": ["biblioteka_nauki"] * n, "added": ["2026-01-01"] * n,
-        "created": [""] * n, "token_count": [1] * n, "license": ["CC-BY-4.0"] * n, "attribution": list(CITATIONS.values()),
-    })
-    path = tmp_path / "biblioteka_nauki.attribution.jsonl"
-    split_attribution(table, path)
-    return path.read_bytes()
+def sidecar_bytes():
+    """The sidecar as clean_biblioteka_nauki writes it (its line shape and serialiser), so a change to the writer breaks the reader's test."""
+    lines = [merge_basis({"id": row_id, "attribution": citation}, "depositor", "https://bibliotekanauki.pl/api/articles/1", "2026-10-05/2026-10-06")
+             for row_id, citation in CITATIONS.items()]
+    return write_sidecar(lines)
 
 
 def fake_hub(monkeypatch, files):

src/test_licence_basis.py

@@ -115,5 +115,39 @@ class MergeBasisTest(unittest.TestCase):
         self.assertEqual(line["licence_basis"], "none")  # the input is not mutated
 
 
+class ReleaseYearTest(unittest.TestCase):
+    """The year rule's table, shared by biblioteka_nauki and open_icm_pl."""
+
+    def test_release_year_is_the_first_year_of_the_licence_version(self):
+        for label, year in [("CC-BY-2.0", 2004), ("CC-BY-3.0", 2007), ("CC-BY-3.0-PL", 2007), ("CC-BY-SA-3.0", 2007),
+                            ("CC-BY-SA-3.0-PL", 2007), ("CC-BY-4.0", 2013), ("CC-BY-SA-4.0", 2013)]:
+            with self.subTest(label=label):
+                self.assertEqual(lb.release_year(label), year)
+        self.assertEqual(set(lb.RELEASE), {"CC-BY-2.0", "CC-BY-3.0", "CC-BY-3.0-PL", "CC-BY-SA-3.0", "CC-BY-SA-3.0-PL", "CC-BY-4.0", "CC-BY-SA-4.0"})
+
+    def test_release_year_fails_for_a_label_it_does_not_list(self):
+        for label in ("CC-BY-2.5", "CC-BY-2.0-PL", "CC-BY-NC-4.0", "cc-by", ""):
+            with self.subTest(label=label), self.assertRaisesRegex(ValueError, "no release year"):
+                lb.release_year(label)
+
+    def test_a_polish_port_is_given_the_year_of_its_generic_version(self):
+        for generic, port in [("CC-BY-3.0", "CC-BY-3.0-PL"), ("CC-BY-SA-3.0", "CC-BY-SA-3.0-PL")]:
+            with self.subTest(port=port):
+                self.assertEqual(lb.release_year(port), lb.release_year(generic))
+
+    def test_created_year_is_the_start_year(self):
+        for created, year in [("2011", 2011), ("2021-05", 2021), ("2024-01-31", 2024), ("2013-12-31/2014-01-02", 2013)]:
+            with self.subTest(created=created):
+                self.assertEqual(lb.created_year(created), year)
+
+    def test_created_year_fails_without_four_leading_digits(self):
+        for created in ("", "201", "n.d.", " 2011", "x2011"):
+            with self.subTest(created=created), self.assertRaisesRegex(ValueError, "no start year"):
+                lb.created_year(created)
+
+    def test_reason_name(self):
+        self.assertEqual(lb.CREATED_BEFORE, "created_before_licence_version")
+
+
 if __name__ == "__main__":
     unittest.main()

src/test_licence_basis_biblioteka_nauki.py

@@ -0,0 +1,271 @@
+"""Per-record licence basis and reviewed drops of biblioteka_nauki (v2#111): sidecar, evidence file and review table, checked against the shipped
+parquet. The step from the v0.2.5 shard to these files (src/clean_biblioteka_nauki.py) needs that shard, which only git history holds; its pure parts
+are tested in src/test_biblioteka_nauki_contract.py."""
+import json
+import re
+import sys
+from collections import Counter
+from pathlib import Path
+
+import pyarrow.parquet as pq
+import pytest
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+import licence_basis as lb  # noqa: E402
+import licence_basis_biblioteka_nauki as lbn  # noqa: E402
+from clean_biblioteka_nauki import ATTRIBUTION, DATA, EVIDENCE, LICENSE_API, PARQUET, REVIEW, REVIEW_SHA256, STATS, read_review  # noqa: E402
+from sejm_api_common import sha256_file  # noqa: E402
+from sources import SOURCES  # noqa: E402
+
+RESTRICTION_REASONS = {"restriction_notice_no_cc_note", "arr_only_no_cc_note", "restriction_notice_beside_cc_note", "not_a_notice_on_the_work"}
+RULE_OF = {**{reason: rule for rule, groups in lbn.HAND.items() for _, reason in groups}, **dict.fromkeys(RESTRICTION_REASONS, "restriction_notice"),
+           lbn.CREATED_BEFORE: lbn.CREATED_BEFORE}
+_PEOPLE_OR_ADVISERS = re.compile("(?i)" + "law" + "yer|legal " + "advis|prawn" + "ik|radca")
+LABELS = {"CC-BY-4.0": 15449, "CC-BY-SA-4.0": 9440, "CC-BY-3.0-PL": 7949, "CC-BY-SA-3.0-PL": 2691, "CC-BY-3.0": 2306, "CC-BY-SA-3.0": 7, "CC-BY-2.0": 1}
+
+
+def parquet_ids():
+    return pq.read_table(PARQUET, columns=["id"]).column("id").to_pylist()
+
+
+def sidecar():
+    return lbn.read_sidecar(ATTRIBUTION)
+
+
+def review_table():
+    return [line.split(",") for line in REVIEW.read_text(encoding="utf-8").splitlines()]
+
+
+def evidence():
+    return json.loads(EVIDENCE.read_text(encoding="utf-8"))
+
+
+@pytest.fixture(scope="module")
+def recs():
+    """The shipped rows scanned by the rules, as the build scans them (the citation comes from the sidecar)."""
+    table = pq.read_table(PARQUET)
+    table = table.drop_columns(["author"]).append_column("attribution", [[line["attribution"] for line in sidecar()]])
+    return lbn.scan(table)
+
+
+# --- the shipped files -------------------------------------------------------------------------------------------------
+def test_sidecar_has_a_valid_basis_for_every_row_in_order_and_keeps_its_bytes():
+    lines, raw = sidecar(), ATTRIBUTION.read_bytes()
+    assert lb.check_lines(lines, parquet_ids()) == []
+    assert lbn.sidecar_bytes(lines) == raw and b"\r" not in raw  # LF, default json.dumps, as before
+    assert all(list(line) == ["id", "attribution", *lb.FIELDS] for line in lines)
+
+
+def test_counts_urls_and_dates_per_code():
+    table = pq.read_table(PARQUET, columns=["id", "added", "license", "token_count"]).to_pylist()
+    lines = sidecar()
+    assert Counter(line["licence_basis"] for line in lines) == Counter(file_note=2657, depositor=35186)
+    tokens = Counter()
+    for row, line in zip(table, lines):
+        kind, number = row["id"].removeprefix("biblioteka_nauki_").split("_")
+        code = line["licence_basis"]
+        tokens[code] += row["token_count"]
+        if code == "file_note":
+            assert (line["licence_basis_url"], line["licence_basis_date"]) == (f"https://bibliotekanauki.pl/{kind}/{number}", row["added"])
+        else:
+            assert (line["licence_basis_url"], line["licence_basis_date"]) == (f"https://bibliotekanauki.pl/api/{kind}/{number}", "2026-10-05/2026-10-06")
+    ev = evidence()
+    assert {c: tokens[c] for c in tokens} == {c: v["tokens"] for c, v in ev["by_code"].items()} == {"file_note": 72177558, "depositor": 518747238}
+    assert ev["counts"] == {"file_note": 2657, "publisher": 0, "depositor": 35186, "none": 0} and ev["added_dates"] == ["2026-06-27"]
+    labels = Counter(row["license"] for row in table)
+    assert labels == Counter(LABELS)
+    assert {k: sum(v.values()) for k, v in ev["by_label"].items()} == labels
+
+
+def test_the_basis_fields_are_what_the_rules_give_for_the_shipped_rows(recs):
+    assert [r["id"] for r in recs] == parquet_ids()
+    citations = [line["attribution"] for line in sidecar()]
+    assert lbn.attribution_lines(recs, citations) == sidecar()  # code, URL and date of every line
+    stats = json.loads(STATS.read_text(encoding="utf-8"))
+    assert lbn.measure(recs) == {"rows": stats["kept"], "characters": stats["chars"], "tokens": stats["tokens"]} == evidence()["review"]["shipped"]
+
+
+def test_file_note_rows_are_exactly_the_rows_whose_text_prints_the_labels_licence(recs):
+    noted = {r["id"] for r in recs if r["note"] == "file_note"}
+    assert len(noted) == 2657 and noted == {line["id"] for line in sidecar() if line["licence_basis"] == "file_note"}
+    assert Counter(r["note"] for r in recs) == Counter(file_note=2657, conflict=8, none=37843 - 2657 - 8)
+
+
+def test_no_shipped_row_is_one_a_rule_drops(recs):
+    """A shipped row that a rule nominates is in the review table as `keep`; the year rule leaves no shipped row."""
+    review = {r[0]: (r[1], r[2]) for r in review_table()[1:]}
+    nominated = {r["id"] for r in recs if r["note"] == "conflict" or r["mismatch"] or r["restriction"]}
+    assert {i: review[i][0] for i in nominated} == dict.fromkeys(nominated, lbn.KEEP)
+    assert all(r["year"] >= lb.release_year(r["label"]) for r in recs)
+    assert not {r["id"] for r in recs} & {i for i, (decision, _) in review.items() if decision == lbn.DROP}
+
+
+# --- the review table ------------------------------------------------------------------------------------------------
+def test_review_table_is_pinned_and_well_formed():
+    assert sha256_file(REVIEW) == REVIEW_SHA256
+    raw, table = REVIEW.read_bytes(), review_table()
+    assert b"\r" not in raw and raw.endswith(b"\n")
+    assert table[0] == ["id", "decision", "reason"] and all(len(r) == 3 for r in table)
+    ids = [r[0] for r in table[1:]]
+    assert ids == sorted(set(ids))
+    assert {r[1] for r in table[1:]} == {lbn.DROP, lbn.KEEP} and {r[2] for r in table[1:]} <= set(lbn.REASON_TEXT)
+    by_reason = {}
+    for _, decision, reason in table[1:]:
+        by_reason.setdefault(reason, set()).add(decision)
+    assert all(len(v) == 1 and v == {d for d, group in lbn.REASONS.items() if reason in group} for reason, v in by_reason.items())
+    assert Counter(r[1] for r in table[1:]) == Counter(drop=4142, keep=63) and len(table) == 4206
+    assert read_review() == {i: (d, r) for i, d, r in table[1:]}
+
+
+def test_review_matches_the_shipped_rows_the_stats_and_the_evidence():
+    stats, ev = json.loads(STATS.read_text(encoding="utf-8")), evidence()
+    table = review_table()[1:]
+    shipped = set(parquet_ids())
+    assert {i for i, d, _ in table if d == lbn.KEEP} <= shipped and not {i for i, d, _ in table if d == lbn.DROP} & shipped
+    dropped = Counter(reason for _, d, reason in table if d == lbn.DROP)
+    assert dropped == stats["drop_review_by_reason"] and sum(dropped.values()) == stats["drop_review"] == 4142
+    assert {reason: v["rows"] for reason, v in ev["review"]["by_reason"].items()} == Counter(reason for _, _, reason in table)
+    assert ev["review"]["sha256"] == REVIEW_SHA256 and ev["review"]["rows"] == len(table) == 4205
+    assert ev["review"]["decided"]["drop"]["rows"] == 4142 and ev["review"]["rule_order"] == list(lbn.PRIORITY)
+    assert ev["input"]["rows_before_review"] == 41985 == stats["kept"] + stats["drop_review"]
+
+
+def test_clear_cut_drops_of_decision_1a_and_2a():
+    dropped = Counter(r[2] for r in review_table()[1:] if r[1] == lbn.DROP)
+    assert {k: dropped[k] for k in dropped if k != lbn.CREATED_BEFORE} == {
+        "printed_licence_nc_or_nd": 4, "file_is_another_work": 16, "reprint_or_prior_publication": 30, "republished_by_permission": 11,
+        "translation_of_earlier_publication": 17, "translation_title_marker": 5, "api_flagged_reprint_translation": 5,  # decision 1A: 88
+        "restriction_notice_no_cc_note": 97}  # decision 2A
+    assert sum(v for k, v in dropped.items() if k not in (lbn.CREATED_BEFORE, "restriction_notice_no_cc_note")) == 88
+
+
+def test_known_rows_are_in_the_review():
+    reasons = {r[0]: (r[1], r[2]) for r in review_table()[1:]}
+    flagged = set(evidence()["api_flags"])
+    assert len(flagged) == 5 and all(reasons[i] == (lbn.DROP, "api_flagged_reprint_translation") for i in flagged)
+    overlaps = evidence()["overlaps"]
+    assert len(overlaps) == 40 and all(len(rules) > 1 for rules in overlaps.values())
+    ids = {i for i, rules in overlaps.items() if lbn.CREATED_BEFORE in rules}
+    assert len(ids) == 39 and len(set(overlaps) - ids) == 1  # the 40th: an API flag that is also a restriction notice
+    assert Counter(reasons[i][1] == lbn.CREATED_BEFORE for i in ids) == Counter({False: 32, True: 7})  # 32 keep their first drop reason, 7 flip from keep
+
+
+def test_year_rule_numbers_the_report_quotes():
+    ev = evidence()
+    year = ev[lbn.CREATED_BEFORE]
+    assert {k: year[k] for k in ("rows", "characters", "tokens")} == {"rows": 3989, "characters": 184805600, "tokens": 71278767}
+    assert sum(year["by_label"].values()) == 3989 and set(year["release_year"]) == set(lb.RELEASE)
+    overlap = year["overlap"]
+    assert sum(overlap["already_dropped_by_another_rule"].values()) == 32 and sum(overlap["flipped_from_keep"].values()) == 7
+    assert overlap["not_otherwise_in_review"] == 3950 and overlap["dropped_with_this_reason"] == 3957 == 3989 - 32
+    assert ev["review"]["by_reason"][lbn.CREATED_BEFORE] == {"rows": 3957, "characters": 181784176, "tokens": 70103154}
+    assert ev["review"]["by_reason"]["restriction_notice_no_cc_note"] == {"rows": 97, "characters": 14700907, "tokens": 5882338}
+    assert ev["review"]["source"] == {"rows": 41985, "characters": 1739004913, "tokens": 669909430}
+    assert ev["journal_adoption"]["obtainable"] is False and ev["publisher_check"]["done"] is False
+    assert ev["not_screened"]["translations_of_source_texts"]["dropped_by_review"] == {"biblioteka_nauki_articles_534737": "reprint_or_prior_publication"}
+    assert ev["not_screened"]["translations_of_source_texts"]["rows"] == 8
+
+
+# --- hand decisions and rule functions ---------------------------------------------------------------------------------
+def test_hand_decisions_are_unique_per_rule_and_use_known_reasons():
+    for rule, groups in lbn.HAND.items():
+        flat = [i for group in groups.values() for i in group]
+        assert len(flat) == len(set(flat)), rule
+        assert {decision for decision, _ in groups} <= {lbn.DROP, lbn.KEEP} and {reason for _, reason in groups} <= set(lbn.REASON_TEXT)
+        assert all((decision, reason) in {(d, r) for d, g in lbn.REASONS.items() for r in g} for decision, reason in groups)
+    assert list(lbn.PRIORITY) == ["printed_note", "prior_publication", "file_mismatch", "restriction_notice", lbn.CREATED_BEFORE]
+    assert set(RULE_OF.values()) <= set(lbn.PRIORITY) and set(lbn.NOMINATED) == set(lbn.PRIORITY)
+
+
+def test_every_reason_has_a_text_and_one_decision():
+    assert set(lbn.REASONS) == {lbn.DROP, lbn.KEEP} and not set(lbn.REASONS[lbn.DROP]) & set(lbn.REASONS[lbn.KEEP])
+    assert all(text.strip() for text in lbn.REASON_TEXT.values()) and len(lbn.REASON_TEXT) == len(lbn.REASONS[lbn.DROP]) + len(lbn.REASONS[lbn.KEEP])
+
+
+def test_restriction_rule():
+    assert lbn.restriction("Tytuł. Wszelkie prawa zastrzeżone. Kopiowanie bez zgody wydawcy zabronione. " + "x" * 9000) == "clause"
+    assert lbn.restriction("Wszelkie prawa zastrzeżone.\n" + "x" * 9000) == "arr_only"
+    assert lbn.restriction("Przedruk w całości lub w części bez pisemnej zgody redakcji jest zabroniony. " + "x" * 9000) == "clause"
+    assert lbn.restriction("Treść.\n" + "x" * 9000 + "\n All rights reserved. Reproduction without prior written permission is prohibited") == "clause"
+    assert lbn.restriction("Treść. " + "x" * 5000 + " wszelkie prawa zastrzeżone " + "x" * 5000) is None  # middle of the text
+    assert lbn.restriction("Treść bez uwag.") is None
+
+
+def test_file_mismatch_rule():
+    citation = "Jan Kowalski; Anna Nowak | 2020 | Ptaki wodne Mazowsza | Wydawca"
+    assert lbn.file_mismatch("Zupełnie inny tekst o gospodarce. " * 400, citation) is True
+    assert lbn.file_mismatch("Ptaki wodne w Polsce. " + "x " * 500, citation) is False  # a title word in the first 6000 characters
+    assert lbn.file_mismatch("Inny tytuł. " + "x " * 500 + " Autor: Nowak", citation) is False  # a surname in the head
+    assert lbn.file_mismatch("Inny tekst. " * 400, "Jan Kowalski | 2020 | Dom | Wydawca") is False  # no title word of 4 letters: not decidable
+    assert lbn.file_mismatch("Inny tekst. " * 400, " | 2020 | Ptaki wodne | Wydawca") is False  # no author: not decidable
+
+
+def test_prior_publication_rule():
+    citation = "Jan Kowalski | 2020 | Ptaki wodne | Wydawca"
+    assert "reprint_word" in lbn.prior_publication_hits("Przedruk z czasopisma X.\n" + "x" * 5000, citation)
+    assert lbn.prior_publication_hits("Przedruk w tekście dalekim. ".rjust(5000, "x"), citation) == ()  # beyond the front matter
+    assert lbn.prior_publication_hits("Treść.", "Jan Kowalski | 2020 | Ptaki wodne (tłum. z angielskiego) | Wydawca") == ("title_translation",)
+    assert "translator_credit" in lbn.prior_publication_hits("Ptaki wodne\nPrzekład: Jan Kowalski\nTreść artykułu", citation)
+    assert lbn.prior_publication_hits("Treść bez uwag.", citation) == ()
+
+
+def _rec(row_id, label, year, **over):
+    return {"id": row_id, "label": label, "year": year, "note": "none", "mismatch": False, "restriction": None, "prior": (), **over}
+
+
+def test_year_rule_selects_rows_created_before_the_licence_version(monkeypatch):
+    monkeypatch.setattr(lbn, "HAND", {rule: {} for rule in lbn.HAND})
+    monkeypatch.setattr(lbn, "NOT_A_NOTICE", ())
+    recs = [_rec("a", "CC-BY-4.0", 2012), _rec("b", "CC-BY-4.0", 2013), _rec("c", "CC-BY-3.0-PL", 2006), _rec("d", "CC-BY-3.0-PL", 2007),
+            _rec("e", "CC-BY-2.0", 2003), _rec("f", "CC-BY-2.0", 2004)]
+    assert lbn.decisions(recs, set())[lbn.CREATED_BEFORE] == dict.fromkeys("ace", (lbn.DROP, lbn.CREATED_BEFORE))
+    with pytest.raises(ValueError, match="no release year"):
+        lbn.decisions([_rec("z", "CC-BY-NC-4.0", 2020)], set())
+
+
+def test_a_row_dropped_by_an_earlier_rule_keeps_its_first_reason_and_a_kept_one_is_dropped_by_the_year_rule():
+    by_rule = {"printed_note": {"a": (lbn.KEEP, "discusses_licence")},
+               "prior_publication": {"b": (lbn.DROP, "republished_by_permission")},
+               "file_mismatch": {}, "restriction_notice": {"c": (lbn.DROP, "restriction_notice_no_cc_note")},
+               lbn.CREATED_BEFORE: {i: (lbn.DROP, lbn.CREATED_BEFORE) for i in "abcd"}}
+    final = lbn.final_reasons(by_rule)
+    assert final == {"a": (lbn.DROP, lbn.CREATED_BEFORE, lbn.CREATED_BEFORE),  # kept by the printed-note rule, dropped by the year
+                     "b": (lbn.DROP, "republished_by_permission", "prior_publication"), "c": (lbn.DROP, "restriction_notice_no_cc_note", "restriction_notice"),
+                     "d": (lbn.DROP, lbn.CREATED_BEFORE, lbn.CREATED_BEFORE)}
+
+
+def test_basis_url_and_final_reason_helpers():
+    assert lbn.item_url("biblioteka_nauki_articles_12", False) == "https://bibliotekanauki.pl/articles/12"
+    assert lbn.item_url("biblioteka_nauki_books_7", True) == "https://bibliotekanauki.pl/api/books/7"
+    for bad in ("biblioteka_nauki_x_1", "biblioteka_nauki_books_a"):
+        with pytest.raises(ValueError):
+            lbn.item_url(bad, False)
+    assert lbn.basis_of({"id": "biblioteka_nauki_books_7", "note": "file_note", "added": "2026-06-27"}) == ("file_note", "https://bibliotekanauki.pl/books/7", "2026-06-27")
+    assert lbn.basis_of({"id": "biblioteka_nauki_books_7", "note": "none", "added": "2026-06-27"}) == ("depositor", "https://bibliotekanauki.pl/api/books/7", lbn.DEPOSITOR_DATE)
+    by_rule = {"printed_note": {"a": (lbn.KEEP, "discusses_licence"), "b": (lbn.KEEP, "discusses_licence")},
+               "prior_publication": {"a": (lbn.DROP, "republished_by_permission")},
+               "file_mismatch": {"b": (lbn.DROP, "file_is_another_work"), "c": (lbn.KEEP, "text_garbled")},
+               "restriction_notice": {"b": (lbn.DROP, "restriction_notice_no_cc_note")}, lbn.CREATED_BEFORE: {}}
+    final = lbn.final_reasons(by_rule)
+    assert final == {"a": (lbn.DROP, "republished_by_permission", "prior_publication"), "b": (lbn.DROP, "file_is_another_work", "file_mismatch"),
+                     "c": (lbn.KEEP, "text_garbled", "file_mismatch")}  # a drop beats a keep of an earlier rule; the first drop in rule order wins
+    assert lbn.review_csv(final) == "id,decision,reason\na,drop,republished_by_permission\nb,drop,file_is_another_work\nc,keep,text_garbled\n"
+    assert lbn.restriction_decision({"id": "x", "note": "file_note", "restriction": "clause"}) == (lbn.KEEP, "restriction_notice_beside_cc_note")
+    assert lbn.restriction_decision({"id": "x", "note": "none", "restriction": "arr_only"}) == (lbn.KEEP, "arr_only_no_cc_note")
+    assert lbn.restriction_decision({"id": lbn.NOT_A_NOTICE[0], "note": "none", "restriction": "clause"}) == (lbn.KEEP, "not_a_notice_on_the_work")
+    assert lbn.restriction_decision({"id": "x", "note": "none", "restriction": "clause"}) == (lbn.DROP, "restriction_notice_no_cc_note")
+
+
+def test_committed_notes_name_no_adviser_and_no_people():
+    paths = (EVIDENCE, REVIEW, Path(lbn.__file__), DATA / "biblioteka_nauki.md", DATA / "biblioteka_nauki.license-evidence.json")
+    for path in paths:
+        assert not _PEOPLE_OR_ADVISERS.search(path.read_text(encoding="utf-8")), path.name
+    assert not _PEOPLE_OR_ADVISERS.search(json.dumps(SOURCES["biblioteka_nauki"]))
+    assert "@" not in EVIDENCE.read_text(encoding="utf-8") and "@" not in REVIEW.read_text(encoding="utf-8")
+
+
+def test_the_card_and_the_registry_say_journal_adoption_is_unknown():
+    card = " ".join((DATA / "biblioteka_nauki.md").read_text(encoding="utf-8").split())
+    assert "Journal adoption years could not be obtained" in card and "before a journal adopted Creative Commons may therefore remain" in card
+    assert "Journal adoption years could not be obtained" in SOURCES["biblioteka_nauki"]["legal_note"]
+    assert LICENSE_API.exists()