Release ChemBricks curated knowledge 2026-09-17.1

.gitattributes

@@ -58,3 +58,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+data/claims.jsonl filter=lfs diff=lfs merge=lfs -text
+data/evidence.jsonl filter=lfs diff=lfs merge=lfs -text
+data/records.jsonl filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,9 @@
+.build/
+.cache/
+.venv/
+__pycache__/
+.pytest_cache/
+*.pyc
+TOKEN
+.env
+.env.*

CITATION.cff

@@ -0,0 +1,13 @@
+cff-version: 1.2.0
+message: "Please cite ChemBricks when using this dataset."
+type: dataset
+title: "ChemBricks Knowledge: Evidence-Linked Chemistry Questions and Claims"
+version: "2026-09-17.1"
+date-released: "2026-09-17"
+authors:
+  - name: ChemBricks
+    website: "https://chembricks.ai"
+url: "https://huggingface.co/datasets/chembricks/chemistry-knowledge"
+repository-code: "https://github.com/Chembricks/chembricks-knowledge"
+license: MIT
+abstract: "Curated computational chemistry questions, scientific audit trails, structured claims, and linked ChemBricks tool evidence."

CURATION.md

@@ -0,0 +1,57 @@
+# Curation and provenance
+
+This is a dated public projection of the ChemBricks knowledge corpus. The creator, ChemBricks, requested the MIT license for this release. Source records are read without editing the source corpus, validation reports, review receipts, ledger, queue, or worker instructions.
+
+## What qualifies
+
+Each source record must be current, have a completed ledger reference, and have unchanged record, trace and tool-log hashes. The release builder repeats the existing pure G1-G8 checks under the source validation policy and requires their claim results to agree with the stored report. It verifies applicable G9 replay evidence and G10 referee integrity. A record must have a passing independent model referee or a recorded building-agent trace review bound to the exact trace hash.
+
+The word curated describes this computational review process. Building-agent reviews are AI reviews; they are not presented as independent human chemist annotations.
+
+The existing source-confidence projection is applied transitively. A claim is eligible only when it and its arithmetic dependencies have passed, none are quarantined, evidence is linked, no dependency issue is found, and prediction timing has not failed. Low-trust, screening-grade, model-limit and unverified-timing qualifications remain attached.
+
+The **records** subset contains complete, unchanged question/answer/trace text only when every structured claim is eligible and the record passes G6. Full prose is never made clean by deleting only its structured disputed claims.
+
+The **claims** subset additionally contains eligible claims from mixed-result investigations. Their original record question and Limitations section supply context; no full answer from an ineligible record is presented as a clean answer. These claims keep their own statement, method, conditions, checks, source confidence and evidence. A failed design target is not converted to a passed finding.
+
+The **evidence** subset contains every non-protocol tool-call row from the retained source captures, including intermediate calculations and recorded failures. These are raw observations, not an additional set of validated claims. Identical capture hashes are stored once; multiple questions or revisions sharing a capture are not independent replications.
+
+## Public-copy transformations
+
+- Chemical arguments, responses, numeric values, response request IDs, model metadata and claim text are preserved.
+- The release omits MCP protocol advertisements, private endpoint configuration, local runtime controls and worker configuration.
+- Request-envelope client metadata is removed because it may contain local workspace paths or session metadata. Response metadata remains intact. Original tool-row hashes are retained separately from newly computed public-row hashes.
+- Source-record hashes, full source-tool-log hashes, source-validation hashes, ledger commitments, curation decisions and source-code hashes are included. A source-tool-log hash identifies the original capture; the filtered public evidence file is not claimed to have that same file hash.
+- Variable-shape scientific objects are stored losslessly in columns ending in `_json`. This avoids incompatible JSON/Arrow types in the Hugging Face viewer. Decode these columns with `json.loads`.
+- Serialization uses UTF-8 and JSON escaping. Decoding restores the original text, including exact tool-response string values.
+- The owner-authorized release license is `mit`. Historical source license labels remain in the provenance index as historical metadata; the license of this public release is given by LICENSE and the dataset card.
+- Secret and private-host scans check the material selected for publication. Records with a remaining match are held out rather than having scientific text silently rewritten.
+
+The release manifest states exact counts and exclusions. No new ChemBricks calculations or model-generated chemistry answers are produced by packaging.
+
+## Evidence versus experimental truth
+
+Passed validation means that a claim meets the recorded provenance and consistency requirements. It does not establish experimental accuracy, causal mechanism, a general law of chemical space, or successful synthesis.
+
+The dataset preserves the distinction between endpoint predictions and experimental measurements, logP and solubility, computed cross-route discrepancies and calibrated error bars, and prospective predictions and retrospective explanations. A calculation's returned trust factor is not an experimentally measured confidence probability.
+
+G9 is sampled, not universal. Phase 0 records may have historically skipped G10. Individual gate states and referee scores are available on each row. The exact source policy versions and hashes are recorded; the release does not apply a new chemistry tolerance.
+
+## Splits and duplicate observations
+
+This release has one split named `corpus`. At packaging time the source repository has no frozen scaffold holdout, so this is not a production training split or an independent evaluation benchmark. No random row split is supplied.
+
+Before an evaluation, keep source captures, revisions, question paraphrases and linked comparisons together, then define a documented scaffold-based holdout from the captured structures. The molecule lists and source capture IDs help with this, but molecules appearing only in returned candidate lists must also be considered. A held-out result must not reappear through a derived question or the claims/evidence subsets.
+
+## Rebuilding
+
+From the source repository:
+
+```bash
+python -B huggingface/build_dataset.py
+python -B huggingface/write_card.py
+python -B huggingface/verify.py --seal
+python -B huggingface/verify.py
+```
+
+Rebuilding takes a new snapshot. It is not a promise to recreate the same release after new records or supersessions arrive. The ledger head, source-code hashes and snapshot time identify the source state. Release verification is offline and makes no chemistry calls.

DATA_DICTIONARY.md

@@ -0,0 +1,77 @@
+# Data dictionary
+
+Every JSONL line is one JSON object. Three named Hugging Face configurations use the same unsplit `corpus` designation.
+
+## records
+
+One complete eligible investigation per row. The useful reading columns are `question`, `beginner_question`, `answer`, `trace_markdown` and `limitations`. The beginner question is an existing source paraphrase, not a new claim.
+
+| Columns | Meaning |
+|---|---|
+| record_id, created_at | Stable source identity and original creation time |
+| family, tier, template_id | Source question taxonomy and template |
+| paraphrases | Recorded alternative phrasings; not independent examples |
+| molecule_smiles | Canonical structures in the record registry |
+| claims_json, molecules_json | Complete structured claims and molecule registry, encoded as JSON strings |
+| interpretations_json, derived_questions_json | Source interpretations and proposed follow-ups |
+| source_confidence_json | Computed confidence projection for every claim, including dependencies and warnings |
+| prediction_timing | Whether recorded pre-call writing order was verified, unverified, or not applicable under the source policy |
+| validation_gates_json | Original G1-G11 statuses |
+| referee_score, referee_model | Recorded independent model review; null or empty when not supplied |
+| builder_review_recorded | Whether a matching building-agent trace-review receipt exists |
+| source_model | Recorded question-writer model |
+| source_capture_id | SHA-256 of the original complete tools.jsonl; a grouping key |
+| source_record_sha256, source_trace_sha256 | Hashes of the original source files |
+| ledger_entry, ledger_line | Commitment in provenance/source-ledger.jsonl |
+| related_record_ids | Explicit supersedes and derived_from links |
+| tags | Propagated confidence, method and timing qualifications |
+| claims_count, tool_calls_count | Counts for this record and its retained non-protocol capture |
+| creator, license | ChemBricks and mit for this release |
+
+## claims
+
+One eligible claim per row. `id` is `record_id:claim_id`. Shared fields have the meanings above.
+
+| Columns | Meaning |
+|---|---|
+| statement, claim_type, property | Original claim wording, category and property identifier |
+| value, value_json, unit | Numeric convenience value, lossless original JSON value, and source unit |
+| verdict | Always passed in this subset |
+| tool, model, trust_factor | Actual recorded method; nullable trust when unavailable |
+| conditions_json | Source phase, geometry, solvent, temperature and state |
+| claim_json | Complete original claim including its evidence and checks |
+| source_confidence_json | Dependency-aware confidence for this claim |
+| full_record_eligible | Whether the complete source investigation also appears in records |
+| limitations | The source Limitations section, retained even for a claim-only source |
+
+A null scalar value can be valid for a directional ranking or a qualitative claim. `value_json` is authoritative for the original type. Null does not mean zero. Trust factors and screening outputs retain their documented limitations.
+
+## evidence
+
+One public tool-call row per pair of `source_capture_id` and `request_id`.
+
+| Columns | Meaning |
+|---|---|
+| tool, status, timestamp, duration_ms | Recorded execution information |
+| args_json, response_json | Exact chemical arguments and response, represented as JSON strings |
+| source_line | Original line number; gaps reflect omitted protocol rows |
+| public_row_json | Complete retained public row with client request metadata removed |
+| source_row_sha256 | Original row hash before public-copy metadata removal |
+| row_sha256 | Hash of the public row excluding its own sha256 field |
+| omitted_metadata_fields | Request-envelope metadata paths removed from the public row |
+
+Join a claim to evidence using both its source capture ID and each evidence request ID. Claim JSON paths start at the full decoded response. JSON-encoded text content may need decoding while traversing a path.
+
+The public-row hash uses SHA-256 over JSON with sorted keys, compact separators, UTF-8 characters unescaped, no NaN, and the `sha256` key omitted. The original response metadata is preserved, including request IDs. The source and public row hashes can differ without any chemical change.
+
+## Supporting files
+
+- `schemas/*.schema.json`: exact public row schemas.
+- `provenance/records.jsonl`: source hashes, original gate states, review receipts and historical license labels.
+- `provenance/selection.jsonl`: eligible and excluded claim IDs, with reasons propagated through dependencies.
+- `provenance/exclusions.json`: record-level exclusions.
+- `provenance/source-ledger.jsonl`: frozen ledger prefix, including commitments to sources outside the selected release.
+- `manifest.json`: counts, source state, policies, transformations and file hashes.
+- `SHA256SUMS`: checksums of the distributable package.
+
+The package verifier checks internal integrity and evidence links. Source-file hashes are commitments to the original private corpus; the package does not contain every original source file required to reconstruct that corpus.

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ChemBricks
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,3 +1,229 @@
 ---
-license: mit
+{
+  "pretty_name": "ChemBricks Knowledge: Evidence-Linked Chemistry",
+  "license": "mit",
+  "language": [
+    "en"
+  ],
+  "task_categories": [
+    "question-answering",
+    "text-generation"
+  ],
+  "tags": [
+    "chemistry",
+    "computational-chemistry",
+    "scientific-reasoning",
+    "tool-use",
+    "provenance",
+    "synthetic",
+    "text"
+  ],
+  "annotations_creators": [
+    "machine-generated"
+  ],
+  "language_creators": [
+    "machine-generated"
+  ],
+  "size_categories": [
+    "1K<n<10K"
+  ],
+  "configs": [
+    {
+      "config_name": "records",
+      "default": true,
+      "data_files": [
+        {
+          "split": "corpus",
+          "path": "data/records.jsonl"
+        }
+      ]
+    },
+    {
+      "config_name": "claims",
+      "data_files": [
+        {
+          "split": "corpus",
+          "path": "data/claims.jsonl"
+        }
+      ]
+    },
+    {
+      "config_name": "evidence",
+      "data_files": [
+        {
+          "split": "corpus",
+          "path": "data/evidence.jsonl"
+        }
+      ]
+    }
+  ]
+}
 ---
+
+# ChemBricks Knowledge
+
+**Does caffeine prefer water or an oil-like liquid?**  
+**Why can adding one small group change a molecule's behavior?**  
+**Can we design a molecule that interacts more favorably with water while meeting other constraints?**  
+**How much energy does it take to remove an electron from a molecule?**
+
+These are the kinds of questions behind this dataset. Each investigation connects a question to recorded calculations, an answer, and the evidence needed to examine that answer.
+
+Created and curated by **[ChemBricks](https://chembricks.ai)** using our **[ChemBricks AI platform](https://cmbx.ai)**.
+
+![Physics, models, tools, questions, claims, checks and reusable context, with a feedback loop from checks to questions](assets/knowledge-path.png)
+
+[Download the vector figure](assets/knowledge-path.svg).
+
+*Physics informs the models; questions guide the calculations; checks determine which claims can become reusable context. The workflow also includes empirical descriptors and semiempirical methods, identified by their actual tool and model. The figure is a workflow schematic, not a claim that every row was independently validated by a high-level reference calculation.*
+
+## What you get
+
+This release contains **346 complete curated investigations**, **6,665 eligible claims**, and **8,001 recorded tool-call pairs**.
+
+The claim subset draws from **475 source investigations**. It includes usable findings from investigations whose complete traces contain a disputed, failed, inconclusive or range-quarantined claim. Those full traces are excluded from the default records subset. The evidence table preserves intermediate observations, including failures; an evidence row is not itself a validated claim.
+
+| Configuration | Rows | Contents |
+|---|---:|---|
+| records, default | 346 | Questions, answers, scientific audit trails, molecule identities, all claims and their qualifications |
+| claims | 6,665 | Individually eligible findings with methods, conditions, checks and evidence links |
+| evidence | 8,001 | Chemical arguments and returned responses, with original request IDs and provenance |
+
+All three configurations use the split **corpus**. This is an unsplit release, not an independent evaluation benchmark.
+
+Snapshot: **2026-09-17T08:20:04Z**. Release: **2026-09-17.1**. The snapshot considered 479 current records from a ledger of 525 entries. It contains 462 distinct source captures across the claim/evidence release. Multiple records sharing a capture are not separate simulations.
+
+## A familiar example
+
+One included investigation is **rec_20260914_1abcb4**:
+
+> Why does the model say caffeine prefers water or octanol, and do its polarity and structure descriptors support that answer?
+
+Open its row to see the recorded answer, methods, conditions and Limitations section. Numerical results remain attached to their tool evidence. In the partition questions, the oil-like reference liquid is **octanol**. The computed quantity is logP for the recorded molecular form, not a direct measurement of how much material dissolves in water.
+
+## Read a record
+
+Load this dataset from [Hugging Face](https://huggingface.co/datasets/chembricks/chemistry-knowledge):
+
+```python
+from datasets import load_dataset
+
+records = load_dataset("chembricks/chemistry-knowledge", "records", split="corpus")
+print(records[0]["question"])
+print(records[0]["answer"])
+print(records[0]["limitations"])
+```
+
+For a local copy, run from this dataset directory:
+
+```python
+from datasets import load_dataset
+
+records = load_dataset(
+    "json",
+    data_files={"corpus": "data/records.jsonl"},
+    split="corpus",
+    cache_dir=".cache/datasets",
+)
+```
+
+The data also works with ordinary Python. See [examples/read_dataset.py](examples/read_dataset.py).
+
+## Follow a claim to its evidence
+
+```python
+import json
+from datasets import load_dataset
+
+claims = load_dataset("chembricks/chemistry-knowledge", "claims", split="corpus")
+evidence = load_dataset("chembricks/chemistry-knowledge", "evidence", split="corpus")
+
+item = claims[0]
+claim = json.loads(item["claim_json"])
+reference = claim["evidence"][0]
+call = next(
+    row for row in evidence
+    if row["source_capture_id"] == item["source_capture_id"]
+    and row["request_id"] == reference["request_id"]
+)
+response = json.loads(call["response_json"])
+print(item["statement"])
+print(item["conditions_json"])
+print(reference["path"])
+print(response)
+```
+
+Columns ending in **_json** contain JSON strings so varying scientific structures load consistently in the dataset viewer. [DATA_DICTIONARY.md](DATA_DICTIONARY.md) describes the columns and JSON-path convention.
+
+## How the data was created
+
+A question specifies molecules, methods, constraints and a budget. An isolated AI worker calls ChemBricks tools through a logging proxy and writes a scientific audit trail. Mechanical gates check schema, safety-screen completion, number provenance, methods, ranges, cross-checks and trust tags. Phase 1 uses an independent model referee and sampled replay checks. Accepted source records enter a hash-chained ledger.
+
+For this release, the original evidence hashes and mechanical checks were verified again offline. Applicable referee and replay evidence were checked. Arithmetic claims inherit the confidence limits of their source claims; a passed calculator result cannot upgrade an unresolved source.
+
+The default records subset requires every claim to qualify. This release includes 325 full records with a passing independent model referee and 164 with a matching recorded building-agent trace review. These counts overlap. Building-agent review is AI review, not an independent human annotation. Historical Phase 0 records retain their original gate states.
+
+The original question, answer, scientific trace, numerical claims and chemical responses are not scientifically rewritten during packaging. Local client metadata is removed from public request envelopes. [CURATION.md](CURATION.md) explains selection, privacy transformations and provenance.
+
+## Coverage
+
+| Family | Question type | Complete records |
+|---|---|---:|
+| A1 | Facts and molecular properties | 54 |
+| A2 | Facts and molecular properties | 14 |
+| A3 | Facts and molecular properties | 157 |
+| B4 | Chemical series | 1 |
+| B6 | Chemical series | 1 |
+| C | Comparisons and counterfactuals | 82 |
+| C2 | Comparisons and counterfactuals | 1 |
+| E2 | Molecule design and discovery tasks | 1 |
+| E5 | Molecule design and discovery tasks | 35 |
+
+The complete-record subset covers 281 distinct canonical molecule strings in its recorded registries. This is a deliberately selected corpus of molecular properties, comparisons and design studies, not a representative sample of all chemical space. Paraphrases, related molecules and derived questions introduce substantial dependence.
+
+## What verified means here
+
+Verified means **traceable to the recorded computation and checked under its declared policy**. It does not mean experimentally established truth.
+
+- Predictions retain their actual model, conditions, applicability and trust information. A high tool trust factor is not a calibrated experimental confidence probability.
+- Cross-route comparisons can support consistency without proving a mechanism or supplying an experimental error bar.
+- Interpretations are distinguished from measurements. A missing descriptor cannot establish a proposed causal explanation.
+- Some historical traces have unverified pre-call prediction timing. Their comparisons remain descriptive. The prediction_timing column preserves this distinction.
+- Low-trust and screening-grade results retain their tags. A passed claim can still have a limited domain of use.
+- Model-based designs are tested computational proposals. They do not establish synthesis, laboratory safety, availability, novelty, or broad chemical laws.
+- The underlying model-training datasets, model weights and full high-level simulation trajectories are not included. This release contains the recorded outputs and knowledge-building investigations.
+
+## Intended uses and evaluation limits
+
+Use the corpus to study evidence-grounded chemistry assistance, retrieve qualified computational context, inspect tool use, or develop scientific question-answering systems. Retain methods, uncertainty, limitations and provenance when constructing a downstream example.
+
+No frozen scaffold holdout exists in the source snapshot. Before training and evaluation, define and document one that keeps linked records, shared captures, generated candidates and scaffold-related molecules from leaking across partitions. The claims and evidence subsets are alternate views of the same source material, not independent datasets.
+
+## Integrity and release files
+
+Run **python -B verify.py** with Python 3.11+ and jsonschema to verify file checksums, public schemas, the ledger commitment chain, preserved trace hashes, claim eligibility and evidence links.
+
+[manifest.json](manifest.json) records the exact source state, counts, code hashes and transformations. [SHA256SUMS](SHA256SUMS) covers the distributable files. The provenance directory retains source hashes and selection decisions. See [UPLOAD.md](UPLOAD.md) for publishing instructions.
+
+## Creators, license and citation
+
+**Creator and publisher:** ChemBricks  
+**Company:** [chembricks.ai](https://chembricks.ai)  
+**AI platform:** [cmbx.ai](https://cmbx.ai)  
+**License:** [MIT](LICENSE), copyright 2026 ChemBricks
+
+This release's curated data, documentation and figure are released under MIT at the dataset owner's direction. Historical source license labels are retained only in the provenance index. They describe the source records' earlier metadata.
+
+```bibtex
+@misc{chembricks_knowledge_2026,
+  author = {{ChemBricks}},
+  title = {ChemBricks Knowledge: Evidence-Linked Chemistry Questions and Claims},
+  year = {2026},
+  version = {2026-09-17.1},
+  url = {https://huggingface.co/datasets/chembricks/chemistry-knowledge}
+}
+```
+
+[CITATION.cff](CITATION.cff) provides machine-readable citation metadata. Include the Hub revision when citing a particular snapshot; no DOI or associated paper is claimed.
+
+Dataset layout follows the [Hugging Face dataset-card specification](https://huggingface.co/docs/hub/datasets-cards) and [data-file configuration](https://huggingface.co/docs/hub/datasets-data-files-configuration).

SHA256SUMS

@@ -0,0 +1,27 @@
+8272d3b01c1bc7f76679df822f0cffe2f8ba97ce56d5dd74f99491aa30417405  .gitignore
+6d0d63e0c455807dce172b8d4c7f70469c660aef677e17df004aba22f4e530cb  CITATION.cff
+57a77108487644819623b4344750125b3ec04e26d52f56c82d0517babc06bba2  CURATION.md
+9ad70d1cb47c13b00da733594255ffcffdbda42b35ba3eff51d712f2c85cf79a  DATA_DICTIONARY.md
+305a95e714e4c265a76022043a0951a0f055274ec36c730e6f4605048fa4a0e5  LICENSE
+bd31449c904429e49c9860ce39a90c769991626db8add012701dbaaddcb659c8  README.md
+a9b1b35b8cb0f2624885ed456c608b48f02d510bf92c7456b9a8b4ffb292ee16  UPLOAD.md
+2b7511d0ab5154375ed9706c0b100b58093efcd32ec4cee0116428be17cbcc9b  assets/knowledge-path.png
+8a51ce3b0b654cd6d7bc299322ff26fb85b191d064db7c5a70257138c26d5f3e  assets/knowledge-path.svg
+ae22eb2594bcd554c7a7ceb93832c70267698d47b184dfd671b8e6f8b9594027  build_dataset.py
+a73b2b613f39413f8b4f8ecdd820529e15c555cb1861096c81a26178938a90e3  data/claims.jsonl
+3947b3e568526821c9689e84737cc29dadbe8aa766aa536512e75de761188c37  data/evidence.jsonl
+05f65efd63d71eef4f37ce53af1192166958d6d22dba8d21e15e67efa1ff71f6  data/records.jsonl
+2a5605d7d47e79d4d0c2a935e01df097eaf9b37e1a7823bf05f463a7d301c7bc  examples/read_dataset.py
+011f64208a3be1e0a533e197bb92c27ae9d4b9a7556a97e37596b4479bb5787b  manifest.json
+baa550941803bcabfad44ec4e34fbe3388d26cd88aacbce37fe61f2040ee7127  provenance/exclusions.json
+bbc5a8dcd7ef989f946566e4b5ea68c58d8097a2a59f5067fbb5ddf9cf2a7ba2  provenance/records.jsonl
+251bd68e0d57325fd2119a52ff5c8a1a1b8b5fbb5c85a937f80cb901e7ada5a5  provenance/selection.jsonl
+04ecc425deff76da43383e08e8ed89975b224650aa2f443c6cc3964bee293ab1  provenance/source-ledger.jsonl
+e094f21278df1a80788c48238e67044819bc7a4155db228836a36cf874c04e65  schemas/claims.schema.json
+200763fdffc3ab00dccfb806019c81d5d9fd6e0d8ecb1fe8dd49be4a46001d01  schemas/evidence.schema.json
+c9f9e57a3524e9c8eb0a42b6941962b615d543d623e5b07b4f70ca2bb8cd3211  schemas/records.schema.json
+b9da65965c67ee7350775b0b047049903a9cfb9cbc0c8c122a8eb8539c791508  test_release.py
+c9abce3267f5e13db78961110a6269c8abd5f78fb5886e98075b75fcd2c927ac  upload.py
+d78188c85bb1aa1745c35f8a639e5df1418b615ab63dfefa6a7794938e775deb  verification.json
+c0ca1f7de547621149a9ca66c0658a3d441d9169c8cb0e49eacc4726e5c0aea6  verify.py
+9d345a16ef338770723d11047b2a59ddc11bce0644ffaa094b6906bef22215e3  write_card.py

UPLOAD.md

@@ -0,0 +1,27 @@
+# Upload this dataset to Hugging Face
+
+The dataset card is README.md. The three JSONL configurations load without a custom dataset-loading script.
+
+The destination is [chembricks/chemistry-knowledge](https://huggingface.co/datasets/chembricks/chemistry-knowledge), the existing ChemBricks dataset repository. Authenticate by supplying an HF_TOKEN environment variable with write access to that destination. Keep credentials out of this folder and out of chat.
+
+Run these commands from this dataset directory. The card already names the destination; after any local edits, regenerate it, then seal and verify the package:
+
+```bash
+python -B write_card.py --repo-id chembricks/chemistry-knowledge
+python -B verify.py --seal
+python -B verify.py
+```
+
+The optional uploader requires `jsonschema` and the official `huggingface_hub` package. Install them in your chosen Python environment if needed: `python -m pip install jsonschema huggingface_hub`. It validates the package, creates the named dataset repository if needed, and uploads only the files named in the manifest. Local build files, caches and credentials are not included.
+
+```bash
+python -B upload.py --repo-id chembricks/chemistry-knowledge
+```
+
+To create a private repository for an initial inspection, add `--private`. This flag controls creation of a new repository; it does not change the visibility of an existing one.
+
+After upload, check that the records, claims and evidence configurations are visible in the dataset viewer and that the figure renders. Record the resulting dataset URL and immutable Hub revision in your release announcement. A DOI is optional and can be added later; none is claimed by this package.
+
+A DOI, paper, gated-access agreement and custom loader are not required. The package already supplies the dataset card, MIT license, citation metadata, schemas, provenance, checksums, curation policy, examples and upload tooling. It deliberately supplies no train/test split: see CURATION.md before constructing an evaluation.
+
+References: [Hugging Face dataset cards](https://huggingface.co/docs/hub/datasets-cards), [data configurations](https://huggingface.co/docs/hub/datasets-data-files-configuration), and [uploading folders](https://huggingface.co/docs/huggingface_hub/guides/upload).

build_dataset.py

@@ -0,0 +1,368 @@
+"""Build a public, evidence-preserving snapshot. Writes only beside this file.
+
+Run from the source repository with Python 3.11+ and its existing dependencies.
+No worker, chemistry endpoint, source-file write, or repository lock is used.
+"""
+from __future__ import annotations
+
+import argparse
+import copy
+from collections import Counter
+from datetime import datetime, timezone
+import hashlib
+import json
+from pathlib import Path
+import re
+import shutil
+import subprocess
+import sys
+
+sys.dont_write_bytecode = True
+DEST = Path(__file__).resolve().parent
+ROOT = DEST.parent
+sys.path.insert(0, str(ROOT))
+
+
+def dumps(value):
+    return json.dumps(value, ensure_ascii=True, allow_nan=False, sort_keys=True, separators=(",", ":"))
+
+
+def sha(data):
+    return hashlib.sha256(data).hexdigest()
+
+
+def write(relative, content):
+    path = (DEST / relative).resolve()
+    if not path.is_relative_to(DEST):
+        raise ValueError("Output must stay inside huggingface/")
+    path.parent.mkdir(parents=True, exist_ok=True)
+    if isinstance(content, bytes):
+        path.write_bytes(content)
+    else:
+        path.write_text(content, encoding="utf-8")
+    return path
+
+
+def json_file(relative, value):
+    return write(relative, json.dumps(value, ensure_ascii=True, allow_nan=False, indent=2) + "\n")
+
+
+def jsonl_file(relative, rows):
+    return write(relative, "".join(dumps(row) + "\n" for row in rows))
+
+
+# Check material being released, never read credentials or environment files.
+PRIVATE_PATTERNS = {
+    "GitHub credential": r"\b(?:github_pat_[A-Za-z0-9_]{30,}|gh[pousr]_[A-Za-z0-9]{30,})\b",
+    "Hugging Face credential": r"\bhf_[A-Za-z0-9]{25,}\b",
+    "API credential": r"\bsk-(?:ant-|proj-)?[A-Za-z0-9_-]{24,}\b",
+    "private key": r"-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----",
+    "authorization credential": r"(?i)\bBearer\s+[A-Za-z0-9._~+/-]{18,}",
+    "private host": r"(?i)(?:https?://[^\s\"<>]*\.ts\.net\b|/home/[A-Za-z0-9_.-]+/|orchestrator[-_][A-Za-z0-9_.-]+)",
+    "credential URL": r"https?://[^/\s:@]+:[^/\s@]+@",
+}
+
+
+def privacy_issues(value):
+    text = value if isinstance(value, str) else dumps(value)
+    return [name for name, pattern in PRIVATE_PATTERNS.items() if re.search(pattern, text)]
+
+
+def clean_claim_ids(record, confidence):
+    """Use the existing transitive confidence policy, never a passed label alone."""
+    return {claim["id"] for claim in record["claims"]
+            if confidence[claim["id"]]["context_eligible"]}
+
+
+def public_tool_row(original):
+    """Omit client metadata while preserving chemistry and response metadata."""
+    row = copy.deepcopy(original)
+    request = row.get("request", {})
+    removed = []
+    for owner, prefix in [(request, "request"), (request.get("params", {}), "request.params")]:
+        for key in ("_meta", "meta", "metadata"):
+            if key in owner:
+                owner.pop(key)
+                removed.append(prefix + "." + key)
+    row["sha256"] = sha(json.dumps({key:value for key,value in row.items() if key != "sha256"}, sort_keys=True, separators=(",", ":"), ensure_ascii=False, allow_nan=False).encode())
+    return row, removed
+
+
+def receipt_index():
+    receipts = {}
+    source_hashes = {}
+    for path in sorted((ROOT / "docs").glob("*review*.json")):
+        if "referee" in path.name or "repeatability" in path.name:
+            continue
+        raw = path.read_bytes()
+        source_hashes[str(path.relative_to(ROOT))] = sha(raw)
+        document = json.loads(raw)
+        values = document if isinstance(document, list) else document.get("reviews", document.get("records", []))
+        for item in values:
+            rid = item.get("record_id", item.get("current_record"))
+            digest = item.get("trace_sha256")
+            if rid and digest:
+                receipts.setdefault((rid, digest), []).append({
+                    "source": str(path.relative_to(ROOT)), "source_sha256": sha(raw),
+                    "trace_sha256": digest, "reviewer_kind": "building_agent",
+                })
+    return receipts, source_hashes
+
+
+def schema_for(rows):
+    if not rows:
+        raise ValueError("A declared configuration has no rows")
+    keys = set(rows[0])
+    props = {}
+    for key in sorted(keys):
+        types = set()
+        for row in rows:
+            if set(row) != keys:
+                raise ValueError("Inconsistent public columns")
+            value = row[key]
+            types.add("null" if value is None else "boolean" if isinstance(value, bool)
+                      else "integer" if isinstance(value, int) else "number" if isinstance(value, float)
+                      else "array" if isinstance(value, list) else "string" if isinstance(value, str) else "object")
+        # Nullable numeric fields remain a single Arrow-compatible scalar type.
+        if "number" in types:
+            types.discard("integer")
+        props[key] = {"type": sorted(types) if len(types) > 1 else next(iter(types))}
+        if "array" in types:
+            if not all(all(isinstance(v, str) for v in row[key]) for row in rows):
+                raise ValueError("Public list columns must contain strings")
+            props[key]["items"] = {"type": "string"}
+    return {"$schema": "https://json-schema.org/draft/2020-12/schema", "type": "object",
+            "additionalProperties": False, "required": sorted(keys), "properties": props}
+
+
+def knowledge_figure():
+    """Adapt the seven existing repository-native SVG icons into one portable figure."""
+    page = (ROOT / "site/index.html").read_text()
+    icons = re.findall(r'<svg class="pathway-art".*?</svg>', page, re.S)
+    if len(icons) != 7:
+        raise ValueError("Expected the seven existing knowledge-path icons")
+    labels = ["Physics", "Models", "Tools", "Questions", "Claims", "Checks", "Context"]
+    captions = [("Reference energies", "and structures"), ("Learn patterns from", "simulation data"),
+                ("Run calculations", "and keep the evidence"), ("Ask what changes", "and why"),
+                ("State a result", "with its source"), ("Check numbers,", "methods and reasoning"),
+                ("Reuse knowledge", "with its limitations")]
+    parts = ['<svg xmlns="http://www.w3.org/2000/svg" width="1540" height="570" viewBox="0 0 1540 570" role="img" aria-labelledby="title description">',
+             '<title id="title">ChemBricks: from physics to verified context</title>',
+             '<desc id="description">Physics informs models. Tools record calculations. Questions guide tests. Claims cite evidence. Checks examine provenance and consistency. Context preserves results and limitations. Unresolved checks lead to new questions.</desc>',
+             '''<defs><marker id="arrow" markerWidth="8" markerHeight="8" refX="6" refY="4" orient="auto"><path d="M1 1 6 4 1 7" fill="none" stroke="#7c9a91" stroke-width="1.5"/></marker></defs>
+<style>text{font-family:Arial,Helvetica,sans-serif}.diagram-wash{fill:#e7f0eb}.diagram-lines{stroke:#668b7c;stroke-width:1.7;stroke-linecap:round;stroke-linejoin:round}.diagram-faint{stroke:#adc6b9;stroke-width:1.5;fill:none}.diagram-core,.diagram-dot{fill:#286d53}.diagram-nodes{fill:#e6f2e9;stroke:#648e7b;stroke-width:1.5}.diagram-halo{stroke:#a6c4b5;stroke-width:1.5}.diagram-paper{fill:#fff;stroke:#527f6d;stroke-width:1.7;stroke-linejoin:round}.diagram-paper-back{fill:#e1eee5;stroke:#88ab98;stroke-width:1.5}.diagram-strong{stroke:#286d53;stroke-width:2.5;stroke-linecap:round;stroke-linejoin:round;fill:none}.diagram-stamp{fill:#e0efbd;stroke:#789651;stroke-width:1}.diagram-shield-inner{fill:#e7f2e6;stroke:#a0b997;stroke-width:1}.diagram-check{fill:none;stroke:#367844;stroke-width:4;stroke-linecap:round;stroke-linejoin:round}.diagram-approved{fill:#2e674c;stroke:#fff;stroke-width:2}.diagram-approved-mark{stroke:#fff;stroke-width:3;fill:none;stroke-linecap:round;stroke-linejoin:round}.diagram-equation{fill:#4a7162;font-size:11px}</style>''',
+             '<rect width="1540" height="570" rx="26" fill="#f5f8f4"/>',
+             '<text x="48" y="48" fill="#49735d" font-size="14" font-weight="700" letter-spacing="3">CHEMBRICKS KNOWLEDGE</text>',
+             '<text x="48" y="101" fill="#173c2c" font-size="40" font-weight="700">From physics to knowledge you can inspect</text>',
+             '<text x="48" y="137" fill="#576d62" font-size="19">Every reusable claim keeps a path back to its calculation, method and limits.</text>']
+    for i, (icon, label, caption) in enumerate(zip(icons, labels, captions)):
+        x = 48 + i * 209
+        parts.append(f'<rect x="{x}" y="177" width="190" height="245" rx="17" fill="{"#e4efd5" if i == 6 else "#ffffff"}" stroke="#d8e4d8"/>')
+        parts.append(f'<text x="{x+17}" y="204" fill="#7a9683" font-size="12" font-weight="700">0{i+1}</text>')
+        icon = re.sub(r'<svg[^>]*>', f'<svg x="{x+39}" y="207" width="112" height="108" viewBox="0 0 112 108" fill="none">', icon, count=1)
+        parts.append(icon)
+        parts.append(f'<text x="{x+95}" y="345" text-anchor="middle" fill="#173c2c" font-size="23" font-weight="700">{label}</text>')
+        for j, line in enumerate(caption):
+            parts.append(f'<text x="{x+95}" y="{374+j*21}" text-anchor="middle" fill="#576d62" font-size="15">{line}</text>')
+        if i < 6:
+            parts.append(f'<path d="M{x+193} 295h12" fill="none" stroke="#7c9a91" stroke-width="1.8" marker-end="url(#arrow)"/>')
+    parts += ['<path d="M1188 428v20q0 12-12 12H770q-12 0-12-12v-18" fill="none" stroke="#7c9a91" stroke-width="1.8" marker-end="url(#arrow)"/>',
+              '<text x="972" y="491" text-anchor="middle" fill="#527460" font-size="15">Surprises and unresolved checks guide the next question</text>',
+              '<path d="M48 519H1492" stroke="#d9e3d8"/>',
+              '<text x="48" y="548" fill="#45664f" font-size="15">Evidence stays attached: source / method / conditions / limitations</text>',
+              '<text x="1492" y="548" text-anchor="end" fill="#45664f" font-size="15">chembricks.ai  |  cmbx.ai</text>', '</svg>']
+    write("assets/knowledge-path.svg", "\n".join(parts) + "\n")
+
+
+def build():
+    from harness.common import canonical_bytes
+    from harness.ledger import entry_hash, GENESIS
+    from harness.validate import validate, VALIDATOR_VERSION, PROTOCOL, section
+    from harness.phase1_check import review_integrity, replay_integrity
+    from harness.claim_context import project, VERSION
+
+    started = datetime.now(timezone.utc).isoformat(timespec="seconds").replace("+00:00", "Z")
+    ledger_bytes = (ROOT / "ledger/chain.jsonl").read_bytes()
+    if not ledger_bytes.endswith(b"\n"):
+        raise ValueError("Ledger append in progress; run again after it finishes")
+    chain = [json.loads(line) for line in ledger_bytes.splitlines() if line.strip()]
+    previous, identifiers = GENESIS, set()
+    for row in chain:
+        if row["prev"] != previous or row["entry"] != entry_hash(row) or row["record_id"] in identifiers:
+            raise ValueError("Invalid source ledger")
+        previous = row["entry"]
+        identifiers.add(row["record_id"])
+    receipt_map, receipt_sources = receipt_index()
+    # First copy a frozen source snapshot inside the permitted destination.
+    snapshot = DEST / ".build/snapshot"
+    current, excluded, source_status = [], [], Counter()
+    for line, ledger in enumerate(chain, 1):
+        rid = ledger["record_id"]
+        folder = ROOT / "records" / rid[4:8] / rid[8:10] / rid
+        source = {name: (folder / name).read_bytes() for name in ("record.json", "trace.md", "tools.jsonl", "validation.json")}
+        for name, key in (("record.json", "record_sha256"), ("trace.md", "trace_sha256"), ("tools.jsonl", "tools_sha256")):
+            if sha(source[name]) != ledger[key]:
+                raise ValueError(f"Source hash mismatch: {rid}/{name}")
+        validation = json.loads(source["validation.json"])
+        source_status[validation["status"]] += 1
+        if validation["status"] != "validated":
+            excluded.append({"record_id": rid, "reason": "superseded_or_not_current"})
+            continue
+        if validation.get("ledger") != {"line": line, "entry": "sha256:" + ledger["entry"]} or validation["gates"].get("G11") != "pass":
+            excluded.append({"record_id": rid, "reason": "ledger_finalization_incomplete"})
+            continue
+        for name, raw in source.items():
+            write(f".build/snapshot/{rid}/{name}", raw)
+        current.append((rid, line, ledger))
+    print(dumps({"stage": "snapshot", "ledger_entries": len(chain), "current": len(current), "ledger_head": previous}), flush=True)
+
+    records, claims, evidence, provenance, decisions = [], [], [], [], []
+    captured, privacy_excluded, confidence_counts = set(), [], Counter()
+    gates_count, model_count, family_count, property_count = Counter(), Counter(), Counter(), Counter()
+    for index, (rid, ledger_line, ledger) in enumerate(current, 1):
+        folder = snapshot / rid
+        record = json.loads((folder / "record.json").read_bytes())
+        validation = json.loads((folder / "validation.json").read_bytes())
+        trace = (folder / "trace.md").read_text()
+        rows = [json.loads(line) for line in (folder / "tools.jsonl").read_bytes().splitlines() if line.strip()]
+        check = validate(record, trace, rows, policy_version=validation.get("validator_version", VALIDATOR_VERSION))
+        if check["status"] != "validated" or check["claim_results"] != validation["claim_results"]:
+            failed = [k for k,v in check["gates"].items() if v == "fail"]
+            excluded.append({"record_id": rid, "reason": "offline_validation_failed", "gates": failed})
+            continue
+        entry = {"folder": folder, "record": record, "validation": validation, "trace": trace, "rows": rows}
+        integrity = review_integrity(folder, validation) + replay_integrity(entry)
+        if integrity:
+            excluded.append({"record_id": rid, "reason": "review_or_replay_integrity_failed", "issues": integrity})
+            continue
+        receipts = receipt_map.get((rid, ledger["trace_sha256"]), [])
+        if validation["gates"].get("G10") != "pass" and not receipts:
+            excluded.append({"record_id": rid, "reason": "no_recorded_curation"})
+            continue
+        confidence = project(record, validation, rows, trace)
+        eligible = clean_claim_ids(record, confidence)
+        ineligible = sorted(set(confidence) - eligible)
+        original_scientific_rows = [row for row in rows if row["tool"] not in PROTOCOL]
+        public_rows = [public_tool_row(row) for row in original_scientific_rows]
+        scientific_rows = [row for row, _ in public_rows]
+        # Source endpoint configuration and protocol advertisements are not public data.
+        leak = privacy_issues({"question": record["question"], "answer": record["answer"], "trace": trace,
+                               "molecules": record["molecules"], "claims": record["claims"], "rows": scientific_rows})
+        if leak:
+            privacy_excluded.append({"record_id": rid, "reason": "private_material_detected", "categories": leak})
+            continue
+        if not eligible:
+            excluded.append({"record_id": rid, "reason": "no_eligible_claims"})
+            continue
+        timing = next(iter(confidence.values()))["prediction_timing"]
+        referee = validation.get("referee") or {}
+        capture = ledger["tools_sha256"]
+        full = not ineligible and validation["gates"].get("G6") == "pass"
+        common = {"record_id": rid, "question": record["question"]["text"], "family": record["question"]["family"],
+                  "tier": record["question"]["tier"], "template_id": record["question"]["template_id"],
+                  "created_at": record["created_at"], "creator": "ChemBricks", "license": "mit",
+                  "source_capture_id": capture, "prediction_timing": timing,
+                  "source_model": record["harness"]["model"],
+                  "molecule_smiles": [m["smiles_canonical"] for m in record["molecules"]]}
+        for claim in record["claims"]:
+            if claim["id"] not in eligible:
+                continue
+            method = claim.get("method", {})
+            value = claim.get("value")
+            claims.append({**common, "claim_id": claim["id"], "id": rid + ":" + claim["id"],
+                "statement": claim["statement"], "claim_type": claim["type"], "property": claim.get("property", ""),
+                "value": float(value) if isinstance(value, (int,float)) and not isinstance(value,bool) else None,
+                "value_json": dumps(value), "unit": claim.get("unit") or "", "verdict": claim["verdict"],
+                "tool": method.get("tool") or "", "model": method.get("model_id") or "",
+                "trust_factor": float(method["trust_factor"]) if isinstance(method.get("trust_factor"), (float,int)) else None,
+                "tags": confidence[claim["id"]]["tags"], "full_record_eligible": full,
+                "conditions_json": dumps(claim.get("conditions", {})), "claim_json": dumps(claim),
+                "source_confidence_json": dumps(confidence[claim["id"]]),
+                "molecules_json": dumps(record["molecules"]), "limitations": section(trace, "Limitations"),
+                "validation_gates_json": dumps(validation["gates"])})
+            property_count[claim.get("property", claim["type"])] += 1
+        if full:
+            question = record["question"]
+            records.append({**common, "beginner_question": question["paraphrases"][0],
+                "paraphrases": question["paraphrases"], "answer": record["answer"]["text"], "trace_markdown": trace,
+                "claims_count": len(record["claims"]), "tool_calls_count": len(scientific_rows),
+                "claims_json": dumps(record["claims"]), "molecules_json": dumps(record["molecules"]),
+                "interpretations_json": dumps(record.get("interpretations", [])),
+                "derived_questions_json": dumps(record.get("derived_questions", [])),
+                "limitations": section(trace, "Limitations"), "source_confidence_json": dumps(confidence),
+                "validation_gates_json": dumps(validation["gates"]),
+                "referee_score": float(referee["score"]) if isinstance(referee.get("score"), (int,float)) else None,
+                "referee_model": referee.get("model") or "", "builder_review_recorded": bool(receipts),
+                "source_record_sha256": ledger["record_sha256"], "source_trace_sha256": ledger["trace_sha256"],
+                "ledger_entry": ledger["entry"], "ledger_line": ledger_line,
+                "related_record_ids": sorted({v for v in (record.get("supersedes"), question.get("derived_from")) if v}),
+                "tags": sorted({tag for item in confidence.values() for tag in item["tags"]})})
+            family_count[question["family"]] += 1
+            model_count[record["harness"]["model"]] += 1
+            confidence_counts[timing] += 1
+            for key,value in validation["gates"].items():
+                gates_count[key + ":" + value] += 1
+        decisions.append({"record_id": rid, "full_record_eligible": full, "eligible_claim_ids": sorted(eligible),
+                          "excluded_claim_ids": ineligible,
+                          "excluded_claim_details": {cid: confidence[cid] for cid in ineligible}})
+        provenance.append({"record_id": rid, "ledger_line": ledger_line, "ledger": ledger,
+            "source_validation_sha256": sha((folder / "validation.json").read_bytes()),
+            "source_license_label": record.get("license"), "release_license": "mit", "gates": validation["gates"],
+            "validator_version": validation["validator_version"], "harness_version": record["harness"]["harness_version"],
+            "referee": {k: referee[k] for k in ["score", "model", "runner", "rubric_version", "ratings", "input_hashes", "output_sha256"] if k in referee},
+            "builder_review_receipts": receipts, "prediction_timing": timing, "full_record_eligible": full})
+        if capture not in captured:
+            captured.add(capture)
+            for original, (row, removed) in zip(original_scientific_rows, public_rows):
+                evidence.append({"source_capture_id": capture, "request_id": row["request_id"], "tool": row["tool"],
+                    "status": row["status"], "timestamp": row["ts"], "duration_ms": row["duration_ms"],
+                    "source_line": row["line"], "row_sha256": row["sha256"],
+                    "source_row_sha256": original["sha256"], "omitted_metadata_fields": removed,
+                    "args_json": dumps(row["args"]), "response_json": dumps(row["response"]), "public_row_json": dumps(row)})
+        if index % 25 == 0:
+            print(dumps({"stage": "validate", "checked": index, "of": len(current), "records": len(records), "claims": len(claims)}), flush=True)
+    for name, values in [("records", records), ("claims", claims), ("evidence", evidence)]:
+        jsonl_file(f"data/{name}.jsonl", values)
+        json_file(f"schemas/{name}.schema.json", schema_for(values))
+    write("provenance/source-ledger.jsonl", ledger_bytes)
+    jsonl_file("provenance/records.jsonl", provenance)
+    jsonl_file("provenance/selection.jsonl", decisions)
+    json_file("provenance/exclusions.json", {"excluded_records": excluded, "privacy_excluded": privacy_excluded})
+    knowledge_figure()
+    commit = subprocess.run(["git", "rev-parse", "HEAD"], cwd=ROOT, capture_output=True, text=True, check=True).stdout.strip()
+    source_code = {str(path.relative_to(ROOT)): sha(path.read_bytes()) for path in sorted((ROOT / "harness").rglob("*.py"))}
+    manifest = {"release_version": "2026-09-17.1", "snapshot_started_at": started,
+        "created_by": "ChemBricks", "homepage": "https://chembricks.ai", "platform": "https://cmbx.ai", "license": "mit",
+        "source_git_commit": commit, "source_ledger_head": previous, "source_ledger_sha256": sha(ledger_bytes),
+        "source_ledger_entries": len(chain), "source_statuses": dict(source_status), "current_records_considered": len(current),
+        "records": len(records), "claims": len(claims), "evidence_rows": len(evidence),
+        "source_records_with_eligible_claims": len(provenance), "distinct_tool_captures": len(captured),
+        "builder_reviewed_full_records": sum(r["builder_review_recorded"] for r in records),
+        "referee_reviewed_full_records": sum(json.loads(r["validation_gates_json"])["G10"] == "pass" for r in records),
+        "molecules_in_full_records": len({s for r in records for s in r["molecule_smiles"]}),
+        "family_counts": dict(sorted(family_count.items())), "property_counts": dict(sorted(property_count.items())),
+        "writer_model_counts": dict(sorted(model_count.items())), "prediction_timing_counts": dict(confidence_counts),
+        "gate_counts": dict(sorted(gates_count.items())), "excluded_record_counts": dict(Counter(item["reason"] for item in excluded)),
+        "privacy_excluded_records": len(privacy_excluded), "source_confidence_policy": VERSION,
+        "split": "corpus", "frozen_scaffold_split_present": (ROOT / "harness/golden/held-out-scaffolds.json").exists(),
+        "source_code_sha256": source_code, "review_source_sha256": receipt_sources,
+        "transformations": ["Select current ledgered records and recheck frozen evidence without source writes.",
+            "Require a verified independent referee or matching recorded builder trace review.",
+            "Full traces require every claim to be context-eligible and G6 to pass.",
+            "The claims subset selects eligible claims, including from otherwise mixed-result records.",
+            "Retain methods, conditions, low-trust and timing qualifications without scientific rewriting.",
+            "Keep every non-protocol request/response row for retained captures; deduplicate identical full-capture hashes.",
+            "Omit private endpoint configuration, runtime controls, credentials and MCP protocol advertisements.",
+            "Remove request-envelope client metadata; preserve response metadata and chemical arguments exactly. Retain original row hashes alongside separately recomputed public-row hashes.",
+            "Release the selected material under the owner-requested MIT license; preserve historical source license labels in provenance."]}
+    json_file("manifest.json", manifest)
+    # The temporary copies were only needed to isolate validation from live collection.
+    shutil.rmtree(snapshot)
+    print(dumps({"stage": "complete", **{k:manifest[k] for k in ["records","claims","evidence_rows","current_records_considered","privacy_excluded_records"]}}), flush=True)
+    return manifest
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.parse_args()
+    build()

data/claims.jsonl

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

data/evidence.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3947b3e568526821c9689e84737cc29dadbe8aa766aa536512e75de761188c37
+size 25376952

data/records.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:05f65efd63d71eef4f37ce53af1192166958d6d22dba8d21e15e67efa1ff71f6
+size 22742073

examples/read_dataset.py

@@ -0,0 +1,20 @@
+"""Read the release with Python's standard library."""
+import argparse
+import json
+from pathlib import Path
+
+root = Path(__file__).resolve().parents[1]
+parser = argparse.ArgumentParser(description=__doc__)
+parser.add_argument("--record-id")
+args = parser.parse_args()
+with (root / "data/records.jsonl").open() as stream:
+    for line in stream:
+        record = json.loads(line)
+        if args.record_id is None or record["record_id"] == args.record_id:
+            print(record["record_id"])
+            print(record["beginner_question"])
+            print(record["answer"])
+            print("Limitations:", record["limitations"])
+            break
+    else:
+        raise SystemExit("Record not found in the complete-record subset.")

manifest.json

@@ -0,0 +1,491 @@
+{
+  "release_version": "2026-09-17.1",
+  "snapshot_started_at": "2026-09-17T08:20:04Z",
+  "created_by": "ChemBricks",
+  "homepage": "https://chembricks.ai",
+  "platform": "https://cmbx.ai",
+  "license": "mit",
+  "source_git_commit": "73ffceccc9574c26915d1c07d95485a10e8132ea",
+  "source_ledger_head": "23f83c9448387d9fd733638c3dc7af395e9eb07f9fec64ea9d0eaf5db826b40d",
+  "source_ledger_sha256": "04ecc425deff76da43383e08e8ed89975b224650aa2f443c6cc3964bee293ab1",
+  "source_ledger_entries": 525,
+  "source_statuses": {
+    "validated": 479,
+    "superseded": 46
+  },
+  "current_records_considered": 479,
+  "records": 346,
+  "claims": 6665,
+  "evidence_rows": 8001,
+  "source_records_with_eligible_claims": 475,
+  "distinct_tool_captures": 462,
+  "builder_reviewed_full_records": 164,
+  "referee_reviewed_full_records": 325,
+  "molecules_in_full_records": 281,
+  "family_counts": {
+    "A1": 54,
+    "A2": 14,
+    "A3": 157,
+    "B4": 1,
+    "B6": 1,
+    "C": 82,
+    "C2": 1,
+    "E2": 1,
+    "E5": 35
+  },
+  "property_counts": {
+    "FractionCSP3": 3,
+    "MolWt": 4,
+    "NumAliphaticRings": 1,
+    "NumAromaticRings": 2,
+    "NumHAcceptors": 3,
+    "NumHDonors": 3,
+    "RingCount": 2,
+    "aliphatic_ring_count": 1,
+    "amino_nitrogen_xtb_mulliken_charge": 3,
+    "api_acceptance": 4,
+    "aromatic_ring_count": 43,
+    "atomic_charge_most_negative": 5,
+    "candidate_logp_order_difference": 1,
+    "candidate_logp_ordering_primary": 1,
+    "candidate_logp_ordering_screening": 1,
+    "candidate_logp_screening_order_difference": 1,
+    "carbonyl_oxygen_xtb_charge": 3,
+    "ea_vs_negative_lumo_discrepancy": 1,
+    "electron_affinity": 78,
+    "fraction_csp3": 95,
+    "h_bond_acceptor_count": 1,
+    "h_bond_donor_count": 1,
+    "hbond_acceptor_count": 15,
+    "hbond_acceptor_count_change": 1,
+    "hbond_acceptor_count_difference": 2,
+    "hbond_donor_count": 11,
+    "hbond_donor_count_change": 1,
+    "hbond_donor_count_difference": 2,
+    "heavy_atom_count": 18,
+    "heteroatom_count": 1,
+    "heteroatom_identity": 2,
+    "homo_energy": 108,
+    "homo_lumo_gap": 94,
+    "hydrogen_bond_acceptor_count": 61,
+    "hydrogen_bond_acceptors": 4,
+    "hydrogen_bond_donor_count": 49,
+    "hydrogen_bond_donors": 4,
+    "ionization_potential": 106,
+    "ip_homo_absolute_discrepancy": 1,
+    "ip_homo_discrepancy": 3,
+    "ip_minus_ea": 2,
+    "ip_negative_homo_discrepancy": 2,
+    "ip_vs_negative_homo_discrepancy": 27,
+    "koopmans_ip_homo_abs_difference": 1,
+    "koopmans_ip_homo_discrepancy": 18,
+    "koopmans_ip_homo_residual": 1,
+    "koopmans_ip_vs_homo_discrepancy": 1,
+    "labute_asa_change": 1,
+    "logp": 918,
+    "logp_candidate_difference_primary": 1,
+    "logp_candidate_difference_screening": 1,
+    "logp_candidate_order_difference_screening": 1,
+    "logp_candidate_order_screening": 3,
+    "logp_candidate_ordering": 5,
+    "logp_candidate_ordering_screening": 2,
+    "logp_candidate_ranking_difference": 1,
+    "logp_crippen": 1,
+    "logp_crippen_difference": 1,
+    "logp_cross_route_abs_difference": 9,
+    "logp_cross_route_absolute_difference": 77,
+    "logp_cross_route_absolute_discrepancy": 3,
+    "logp_cross_route_agreement_band": 1,
+    "logp_cross_route_difference": 32,
+    "logp_cross_route_discrepancy": 251,
+    "logp_cross_route_effect_spread": 1,
+    "logp_cross_route_shift_difference": 1,
+    "logp_crossroute_abs_difference": 1,
+    "logp_crossroute_absolute_difference": 3,
+    "logp_crossroute_discrepancy": 7,
+    "logp_difference": 1,
+    "logp_edit_cross_route_difference": 1,
+    "logp_edit_cross_route_discrepancy": 1,
+    "logp_edit_effect_cross_route_absolute_difference": 1,
+    "logp_edit_effect_cross_route_discrepancy": 1,
+    "logp_effect_cross_route_abs_difference": 1,
+    "logp_effect_cross_route_absolute_difference": 1,
+    "logp_effect_cross_route_difference": 1,
+    "logp_effect_cross_route_discrepancy": 1,
+    "logp_same_method_absolute_difference": 1,
+    "logp_screening": 78,
+    "logp_screening_candidate_ordering": 3,
+    "logp_screening_candidate_ordering_difference": 1,
+    "logp_screening_candidate_ranking_difference": 3,
+    "logp_screening_change": 51,
+    "logp_screening_crippen": 5,
+    "logp_screening_delta": 4,
+    "logp_screening_difference": 37,
+    "logp_screening_ordering": 1,
+    "logp_screening_ranking": 1,
+    "lumo_energy": 88,
+    "max_abs_xtb_charge": 6,
+    "maximum_absolute_xtb_charge": 5,
+    "maximum_absolute_xtb_charge_change": 1,
+    "maximum_absolute_xtb_charge_extremum": 3,
+    "mol_logp_descriptor": 1,
+    "mol_logp_rdkit": 2,
+    "mol_logp_rdkit_change": 1,
+    "mol_wt_descriptor": 1,
+    "molar_refractivity": 1,
+    "molecular_weight": 132,
+    "molecular_weight_change": 2,
+    "molecular_weight_descriptor": 21,
+    "molecular_weight_descriptor_change": 1,
+    "molecular_weight_descriptor_difference": 1,
+    "molecular_weight_difference": 1,
+    "molecular_weight_rdkit": 1,
+    "molmr": 3,
+    "molmr_descriptor_change": 1,
+    "molwt": 9,
+    "molwt_descriptor": 4,
+    "most_negative_charge": 3,
+    "most_negative_charge_change": 2,
+    "most_negative_q": 5,
+    "most_negative_xtb_charge": 2,
+    "most_negative_xtb_charge_change": 2,
+    "murcko_generic": 1,
+    "murcko_scaffold": 21,
+    "nitrogen_rdkit_index": 1,
+    "num_aliphatic_rings": 6,
+    "num_aromatic_rings": 80,
+    "num_h_acceptors": 174,
+    "num_h_acceptors_change": 4,
+    "num_h_acceptors_difference": 2,
+    "num_h_bond_acceptors": 7,
+    "num_h_bond_donors": 7,
+    "num_h_donors": 159,
+    "num_h_donors_change": 5,
+    "num_h_donors_difference": 1,
+    "num_hbond_acceptors": 10,
+    "num_hbond_donors": 10,
+    "num_heteroatoms": 3,
+    "num_hydrogen_bond_acceptors": 7,
+    "num_hydrogen_bond_donors": 8,
+    "num_rotatable_bonds": 21,
+    "num_saturated_rings": 2,
+    "octanol_minus_water_solvation_balance_change": 1,
+    "octanol_minus_water_solvation_change": 1,
+    "primary_logp_candidate_difference": 2,
+    "rdkit_descriptor_panel": 1,
+    "rdkit_fraction_csp3": 4,
+    "rdkit_mollogp": 27,
+    "rdkit_mollogp_change": 2,
+    "rdkit_molwt": 9,
+    "rdkit_num_aromatic_rings": 4,
+    "rdkit_num_h_acceptors": 5,
+    "rdkit_num_h_donors": 4,
+    "rdkit_num_rotatable_bonds": 2,
+    "rdkit_ring_count": 2,
+    "rdkit_structural_descriptor_panel": 1,
+    "ring_count": 90,
+    "rotatable_bond_count": 7,
+    "saturated_ring_count": 1,
+    "screening_crippen_logp_change": 2,
+    "screening_logp": 2,
+    "screening_logp_candidate_difference": 2,
+    "screening_logp_change": 6,
+    "solvation_balance_octanol_minus_water": 2,
+    "solvation_change_water_minus_octanol": 4,
+    "solvation_energy_octanol": 705,
+    "solvation_energy_octanol_change": 9,
+    "solvation_energy_octanol_difference": 16,
+    "solvation_energy_octanol_minus_water": 179,
+    "solvation_energy_octanol_minus_water_change": 1,
+    "solvation_energy_water": 795,
+    "solvation_energy_water_change": 7,
+    "solvation_energy_water_difference": 9,
+    "solvation_energy_water_minus_octanol": 29,
+    "solvation_energy_water_minus_octanol_change": 2,
+    "solvation_energy_water_minus_octanol_difference": 1,
+    "solvation_free_energy_octanol_minus_water": 1,
+    "solvation_free_energy_relative_split": 1,
+    "solvation_partition_balance_change": 1,
+    "solvation_partition_change_contrast": 1,
+    "solvation_partition_contrast": 1,
+    "solvation_shift_water_minus_octanol": 1,
+    "solvent_balance": 10,
+    "solvent_balance_candidate_difference": 1,
+    "solvent_balance_change": 78,
+    "solvent_balance_difference": 13,
+    "solvent_balance_octanol_minus_water": 57,
+    "solvent_balance_octanol_minus_water_change": 11,
+    "solvent_balance_water_minus_octanol": 1,
+    "solvent_change_balance": 1,
+    "solvent_change_contrast": 2,
+    "solvent_change_split": 1,
+    "solvent_component_balance": 1,
+    "solvent_free_energy_balance": 1,
+    "solvent_free_energy_balance_octanol_minus_water": 1,
+    "solvent_free_energy_difference_octanol_minus_water": 1,
+    "solvent_partition_delta_difference": 1,
+    "solvent_preference_octanol_minus_water": 1,
+    "solvent_preference_shift": 3,
+    "solvent_response_balance": 1,
+    "solvent_transfer_free_energy_change": 2,
+    "topological_polar_surface_area": 1,
+    "tpsa": 794,
+    "tpsa_candidate_ordering": 1,
+    "tpsa_change": 9,
+    "tpsa_difference": 10,
+    "tpsa_molwt_ratio": 1,
+    "tpsa_rdkit_subset": 1,
+    "water_minus_octanol_solvation_change": 2,
+    "water_solvation_candidate_difference": 1,
+    "water_vs_octanol_solvation_shift": 2,
+    "xtb_added_amine_charge": 1,
+    "xtb_added_fluorine_charge": 1,
+    "xtb_added_nitrogen_charge": 1,
+    "xtb_added_oxygen_charge": 1,
+    "xtb_adjacent_carbon_charge_difference": 1,
+    "xtb_charge_most_negative": 3,
+    "xtb_charge_most_positive": 3,
+    "xtb_charge_oxygen": 3,
+    "xtb_charge_span": 15,
+    "xtb_charge_span_change": 3,
+    "xtb_charge_span_difference": 1,
+    "xtb_edited_carbon_charge": 1,
+    "xtb_exocyclic_n_q": 1,
+    "xtb_fusion_carbon_charge_difference": 1,
+    "xtb_local_bond_charge_contrast": 1,
+    "xtb_local_group_charge_difference": 1,
+    "xtb_mapped_nitrogen_charge_far": 1,
+    "xtb_mapped_nitrogen_charge_near": 1,
+    "xtb_max_abs_charge": 12,
+    "xtb_max_abs_charge_change": 1,
+    "xtb_maximum_absolute_charge_difference": 1,
+    "xtb_mean_carbon_charge_difference": 1,
+    "xtb_methoxy_oxygen_charge": 3,
+    "xtb_most_negative_charge": 319,
+    "xtb_most_negative_charge_change": 24,
+    "xtb_most_negative_charge_difference": 24,
+    "xtb_most_negative_charge_order": 1,
+    "xtb_most_negative_oxygen_charge": 3,
+    "xtb_most_negative_q": 84,
+    "xtb_most_negative_q_change": 3,
+    "xtb_most_positive_charge": 27,
+    "xtb_most_positive_charge_change": 3,
+    "xtb_most_positive_charge_difference": 1,
+    "xtb_most_positive_q": 7,
+    "xtb_mulliken_charge_added_nitrogen": 1,
+    "xtb_mulliken_charge_introduced_n": 1,
+    "xtb_mulliken_charge_phenolic_oxygen": 3,
+    "xtb_mulliken_charge_target_carbon": 3,
+    "xtb_nitrogen_charge_change": 1,
+    "xtb_nitrogen_charge_difference": 1,
+    "xtb_outer_carbon_charge_difference": 1,
+    "xtb_retained_ring_n_q": 1,
+    "xtb_ring_n_charge": 3,
+    "xtb_ring_nitrogen_charge": 1,
+    "xtb_ring_oxygen_charge": 3,
+    "xtb_substitution_site_charge_difference": 1,
+    "xtb_target_carbon_charge": 6,
+    "xtb_target_carbon_q": 1
+  },
+  "writer_model_counts": {
+    "gpt-5.6-sol": 341,
+    "sonnet": 5
+  },
+  "prediction_timing_counts": {
+    "unverified": 101,
+    "verified": 245
+  },
+  "gate_counts": {
+    "G10:pass": 325,
+    "G10:skipped": 21,
+    "G11:pass": 346,
+    "G1:pass": 346,
+    "G2:pass": 346,
+    "G3:pass": 346,
+    "G4:pass": 346,
+    "G5:pass": 346,
+    "G6:pass": 346,
+    "G7:pass": 346,
+    "G8:pass": 346,
+    "G9:pass": 14,
+    "G9:skipped": 332
+  },
+  "excluded_record_counts": {
+    "superseded_or_not_current": 46,
+    "no_eligible_claims": 4
+  },
+  "privacy_excluded_records": 0,
+  "source_confidence_policy": "source-confidence-v1",
+  "split": "corpus",
+  "frozen_scaffold_split_present": false,
+  "source_code_sha256": {
+    "harness/__init__.py": "ab08d8b41a75905ad0b0d2588df5a9f923e72778b81feb01b95c4b190f5e6475",
+    "harness/activity.py": "3eaac28c805e02aa0173c2533f7858d39dc7c78ab6cfb6f521b73203837b8ddd",
+    "harness/audit.py": "d1fc2bee121415b6f43066988f2688f2be54d510856b32ef8e88af3f4050e1dc",
+    "harness/campaign.py": "aeb6da101e1892f70fd211b2217327e08e043eac1ccc7d3188a5e6131d40739b",
+    "harness/catalog.py": "2578cf29245b78246c43f47547c2c295fa713cfd51dab8fa58b9c7a59a6f3be3",
+    "harness/check.py": "978be4d23e788772523f833e1961272f234b9290461c4fcfaab38cf7100eac01",
+    "harness/claim_context.py": "1406b4ae72a313b4383028389b42bd625ff1459d69df645a45cb1ad54f185f54",
+    "harness/collection.py": "31a9449733d2eba4108b1bf870479e42f1bc8eed0bdcc626cbd109f2e49a4a9c",
+    "harness/common.py": "feea2e6bd1f93d7704405424b8b842b9bc7864786e83464d7f8759fd92841d45",
+    "harness/coverage.py": "f05ae33128ed5baabd0cd327074387bdb4f2bbf8ab1073bb276da6ec458aade3",
+    "harness/cross_checks.py": "fe5e68a9e760e7c35e7fb1086c91bed28c78a2beb2b39f2b64d02c0ad6a090ce",
+    "harness/design.py": "a7c1635058bc8b1cb644c33184e349c80e3c814781ff39145a983f95dd34ad92",
+    "harness/design_questions.py": "1f252ebf4b7a00c4eff2e7a48c0ed08c736fa52446b9b1e54409f165324760c9",
+    "harness/driver.py": "6b0477e4330756432fb7b84356abb71c9729d11641c98f3d7cb8c56ca763aed1",
+    "harness/edit_questions.py": "c2219573dd7bc1cd8053542375afe29ad239f05c237a7a2531869d8706e5f046",
+    "harness/endpoint_state.py": "20c331b16ab61aa1b473d3abeb80d557886f6cd16d2a99d8ac4c6debbc7c26d8",
+    "harness/env.py": "6fd60ce6a8f5c639e0ab810e54c6e21099682346eabbb6960da01fbef650b9ca",
+    "harness/expand.py": "818253cf7dd9c69f256bad7eb1ebb6b4674050519dbb3a56ca8f1795edcc6db1",
+    "harness/export_training.py": "58d44a0280648da2815911d799b1ff9446585870d266574991f4aa4c079f6972",
+    "harness/generate_questions.py": "df28fbfc806f666986c5beb690971b800eeec96b5a8881ea7e5f88e6997eadde",
+    "harness/golden/__init__.py": "a08547fbcf2933c0d250361c32f61441a45f0356c8bc2df405bd3696c7623a5d",
+    "harness/golden/__main__.py": "4c379ffaef89f3a3d9d7da428f9eb67b8fd180f810356666eecdf963d7aecef5",
+    "harness/golden/policy_review.py": "e4a381407611baeef9016b823ff4aa3b85c86f94179e766aa18d210a0abe2428",
+    "harness/ledger.py": "ef6131c06fe66fc0329f9bb6965288dc8751fbb01b8245db0d956b8c1bd6205e",
+    "harness/locking.py": "b1f7c7074418106e44faf774f856223d69eb1b6db38699ef2d649c36b88dc6c8",
+    "harness/mcp_proxy/__init__.py": "30fa631c411a321eb74a9851ab3ac03786ac8bb9b9be616845353edd4908ab9d",
+    "harness/mcp_proxy/__main__.py": "26d7123a171dc75d962e0fb96233b267780bd4c1766baa47ffad521ad5f2e077",
+    "harness/metrics.py": "70fc2283e49161a18f14111f24f0e1ab7092731d5d0890b467ecab6853bd3856",
+    "harness/named_questions.py": "01ca9c01d6252ae1ce64c6427f7b484d14cbcd7a3681bef97b87523f1954b039",
+    "harness/operations.py": "96326038af70e666943108e0ed4fecf25fce4518373dc9768df0bfcdacb4ab9b",
+    "harness/phase1_check.py": "5ba6db8ed4f957739c39f54e6fe70dee9262e273c18ef5bd597b3507c86d99fc",
+    "harness/phase1_questions.py": "47f168d464e5cba1c311ee133ffe76a0a82e3e265a7333ae3159aba0db15dca0",
+    "harness/predictions.py": "4b794014f0e712873f939fe785e688d1dbbb17e4160cba2ff7ae3ebca68ea526",
+    "harness/referee.py": "92e7f94feb2df268302a8310e7799242b1d054577fc842ed3588c18cf9bec87e",
+    "harness/replay_policy.py": "22279327781267a3a939ae2b72583d636b6be6520e12d0da4e2a6379909b9b80",
+    "harness/runners/__init__.py": "6cc2bf8a63a462d7f4b3b11f2b7dbca63e241a80aff4f1f5f83711852b2aedc2",
+    "harness/runners/claude_code.py": "23a236e047bf17585a7406a8fc0c2016e667daeecaa7d8a4fc759e779fd010a3",
+    "harness/runners/codex.py": "46f6266f75c37ead806d4aaec292a3ee625a128a0d709ce374387680963d81fd",
+    "harness/runners/common.py": "5628d5225b1a32436e70939cf4bfe1794473c5e9e021b941650e458ac7051af7",
+    "harness/runners/files.py": "b5d2ee79d0e9a9c4dd47a0c1d70ebf63bfbeb0683cb61abbc85e291a1b94f004",
+    "harness/runners/policy.py": "f4fc3bd8c9ff39569c9c35dafda408733d0aa357178add0a6c9ea18e3dfb6a33",
+    "harness/runners/processes.py": "d2eb3512dd19a18156270641f404de89bc4e30129f7ca0568a0de8d133afd7ba",
+    "harness/runners/replay.py": "c3e214d4e9794aadb52ae46a46a36a6bc6e9b0924e26b967304a70eb11d5da9c",
+    "harness/validate.py": "e86c7923a2468893b45791073f21001f7ae57c3a1bb1da9ced4b1a0b44b92069"
+  },
+  "review_source_sha256": {
+    "docs/phase0-trace-review.json": "387d57c47a6dffecfd5a06eb72a6647d1ee436b16a4ae28ebe076772eb9e32bc",
+    "docs/phase1-continuation-review.json": "8b783123a046ab8d1b3e206ce2776127374e9bf6d7fd273b88bcd7ca348e0d37",
+    "docs/phase1-second-continuation-review.json": "2c2d0d0cfcd4d190311c467baea295a017fb81bd874f5ee63d93499fdd55216c",
+    "docs/phase1-third-continuation-review.json": "29379e25bf4065b7c98f7031e328866c8a45443940d52587a65e7039b9158cfd",
+    "docs/phase1-trace-review.json": "6c4e26827601792fe718f862bcb2e51491b17670c0a49f75b83daf83cc0ee179"
+  },
+  "transformations": [
+    "Select current ledgered records and recheck frozen evidence without source writes.",
+    "Require a verified independent referee or matching recorded builder trace review.",
+    "Full traces require every claim to be context-eligible and G6 to pass.",
+    "The claims subset selects eligible claims, including from otherwise mixed-result records.",
+    "Retain methods, conditions, low-trust and timing qualifications without scientific rewriting.",
+    "Keep every non-protocol request/response row for retained captures; deduplicate identical full-capture hashes.",
+    "Omit private endpoint configuration, runtime controls, credentials and MCP protocol advertisements.",
+    "Remove request-envelope client metadata; preserve response metadata and chemical arguments exactly. Retain original row hashes alongside separately recomputed public-row hashes.",
+    "Release the selected material under the owner-requested MIT license; preserve historical source license labels in provenance."
+  ],
+  "files": {
+    ".gitignore": {
+      "sha256": "8272d3b01c1bc7f76679df822f0cffe2f8ba97ce56d5dd74f99491aa30417405",
+      "bytes": 75
+    },
+    "CITATION.cff": {
+      "sha256": "6d0d63e0c455807dce172b8d4c7f70469c660aef677e17df004aba22f4e530cb",
+      "bytes": 578
+    },
+    "CURATION.md": {
+      "sha256": "57a77108487644819623b4344750125b3ec04e26d52f56c82d0517babc06bba2",
+      "bytes": 6003
+    },
+    "DATA_DICTIONARY.md": {
+      "sha256": "9ad70d1cb47c13b00da733594255ffcffdbda42b35ba3eff51d712f2c85cf79a",
+      "bytes": 5141
+    },
+    "LICENSE": {
+      "sha256": "305a95e714e4c265a76022043a0951a0f055274ec36c730e6f4605048fa4a0e5",
+      "bytes": 1067
+    },
+    "README.md": {
+      "sha256": "bd31449c904429e49c9860ce39a90c769991626db8add012701dbaaddcb659c8",
+      "bytes": 11417
+    },
+    "UPLOAD.md": {
+      "sha256": "a9b1b35b8cb0f2624885ed456c608b48f02d510bf92c7456b9a8b4ffb292ee16",
+      "bytes": 2277
+    },
+    "assets/knowledge-path.png": {
+      "sha256": "2b7511d0ab5154375ed9706c0b100b58093efcd32ec4cee0116428be17cbcc9b",
+      "bytes": 256644
+    },
+    "assets/knowledge-path.svg": {
+      "sha256": "8a51ce3b0b654cd6d7bc299322ff26fb85b191d064db7c5a70257138c26d5f3e",
+      "bytes": 11144
+    },
+    "build_dataset.py": {
+      "sha256": "ae22eb2594bcd554c7a7ceb93832c70267698d47b184dfd671b8e6f8b9594027",
+      "bytes": 24812
+    },
+    "data/claims.jsonl": {
+      "sha256": "a73b2b613f39413f8b4f8ecdd820529e15c555cb1861096c81a26178938a90e3",
+      "bytes": 39235886
+    },
+    "data/evidence.jsonl": {
+      "sha256": "3947b3e568526821c9689e84737cc29dadbe8aa766aa536512e75de761188c37",
+      "bytes": 25376952
+    },
+    "data/records.jsonl": {
+      "sha256": "05f65efd63d71eef4f37ce53af1192166958d6d22dba8d21e15e67efa1ff71f6",
+      "bytes": 22742073
+    },
+    "examples/read_dataset.py": {
+      "sha256": "2a5605d7d47e79d4d0c2a935e01df097eaf9b37e1a7823bf05f463a7d301c7bc",
+      "bytes": 738
+    },
+    "provenance/exclusions.json": {
+      "sha256": "baa550941803bcabfad44ec4e34fbe3388d26cd88aacbce37fe61f2040ee7127",
+      "bytes": 4979
+    },
+    "provenance/records.jsonl": {
+      "sha256": "bbc5a8dcd7ef989f946566e4b5ea68c58d8097a2a59f5067fbb5ddf9cf2a7ba2",
+      "bytes": 787304
+    },
+    "provenance/selection.jsonl": {
+      "sha256": "251bd68e0d57325fd2119a52ff5c8a1a1b8b5fbb5c85a937f80cb901e7ada5a5",
+      "bytes": 660166
+    },
+    "provenance/source-ledger.jsonl": {
+      "sha256": "04ecc425deff76da43383e08e8ed89975b224650aa2f443c6cc3964bee293ab1",
+      "bytes": 243600
+    },
+    "schemas/claims.schema.json": {
+      "sha256": "e094f21278df1a80788c48238e67044819bc7a4155db228836a36cf874c04e65",
+      "bytes": 2513
+    },
+    "schemas/evidence.schema.json": {
+      "sha256": "200763fdffc3ab00dccfb806019c81d5d9fd6e0d8ecb1fe8dd49be4a46001d01",
+      "bytes": 1145
+    },
+    "schemas/records.schema.json": {
+      "sha256": "c9f9e57a3524e9c8eb0a42b6941962b615d543d623e5b07b4f70ca2bb8cd3211",
+      "bytes": 2936
+    },
+    "test_release.py": {
+      "sha256": "b9da65965c67ee7350775b0b047049903a9cfb9cbc0c8c122a8eb8539c791508",
+      "bytes": 4577
+    },
+    "upload.py": {
+      "sha256": "c9abce3267f5e13db78961110a6269c8abd5f78fb5886e98075b75fcd2c927ac",
+      "bytes": 1550
+    },
+    "verification.json": {
+      "sha256": "d78188c85bb1aa1745c35f8a639e5df1418b615ab63dfefa6a7794938e775deb",
+      "bytes": 1540
+    },
+    "verify.py": {
+      "sha256": "c0ca1f7de547621149a9ca66c0658a3d441d9169c8cb0e49eacc4726e5c0aea6",
+      "bytes": 10118
+    },
+    "write_card.py": {
+      "sha256": "9d345a16ef338770723d11047b2a59ddc11bce0644ffaa094b6906bef22215e3",
+      "bytes": 12455
+    }
+  }
+}

provenance/exclusions.json

@@ -0,0 +1,205 @@
+{
+  "excluded_records": [
+    {
+      "record_id": "rec_20260914_273ed3",
+      "reason": "superseded_or_not_current"
+    },
+    {
+      "record_id": "rec_20260914_47ac1c",
+      "reason": "superseded_or_not_current"
+    },
+    {
+      "record_id": "rec_20260914_c5d2dd",
+      "reason": "superseded_or_not_current"
+    },
+    {
+      "record_id": "rec_20260914_6551be",
+      "reason": "superseded_or_not_current"
+    },
+    {
+      "record_id": "rec_20260914_9b9afe",
+      "reason": "superseded_or_not_current"
+    },
+    {
+      "record_id": "rec_20260914_14485e",
+      "reason": "superseded_or_not_current"
+    },
+    {
+      "record_id": "rec_20260914_46c73c",
+      "reason": "superseded_or_not_current"
+    },
+    {
+      "record_id": "rec_20260914_ca6e5d",
+      "reason": "superseded_or_not_current"
+    },
+    {
+      "record_id": "rec_20260914_938fe1",
+      "reason": "superseded_or_not_current"
+    },
+    {
+      "record_id": "rec_20260914_2a7bd5",
+      "reason": "superseded_or_not_current"
+    },
+    {
+      "record_id": "rec_20260914_cc8eec",
+      "reason": "superseded_or_not_current"
+    },
+    {
+      "record_id": "rec_20260914_fd0674",
+      "reason": "superseded_or_not_current"
+    },
+    {
+      "record_id": "rec_20260914_afd7a9",
+      "reason": "superseded_or_not_current"
+    },
+    {
+      "record_id": "rec_20260914_3b8981",
+      "reason": "superseded_or_not_current"
+    },
+    {
+      "record_id": "rec_20260914_d8b8b0",
+      "reason": "superseded_or_not_current"
+    },
+    {
+      "record_id": "rec_20260914_94999a",
+      "reason": "superseded_or_not_current"
+    },
+    {
+      "record_id": "rec_20260915_c7e0ba",
+      "reason": "superseded_or_not_current"
+    },
+    {
+      "record_id": "rec_20260915_6a6ef0",
+      "reason": "superseded_or_not_current"
+    },
+    {
+      "record_id": "rec_20260915_7ef45e",
+      "reason": "superseded_or_not_current"
+    },
+    {
+      "record_id": "rec_20260915_7aa885",
+      "reason": "superseded_or_not_current"
+    },
+    {
+      "record_id": "rec_20260915_951052",
+      "reason": "superseded_or_not_current"
+    },
+    {
+      "record_id": "rec_20260915_aba5b0",
+      "reason": "superseded_or_not_current"
+    },
+    {
+      "record_id": "rec_20260915_13378d",
+      "reason": "superseded_or_not_current"
+    },
+    {
+      "record_id": "rec_20260915_4524b6",
+      "reason": "superseded_or_not_current"
+    },
+    {
+      "record_id": "rec_20260915_e935ea",
+      "reason": "superseded_or_not_current"
+    },
+    {
+      "record_id": "rec_20260916_cf31f0",
+      "reason": "superseded_or_not_current"
+    },
+    {
+      "record_id": "rec_20260916_bd6402",
+      "reason": "superseded_or_not_current"
+    },
+    {
+      "record_id": "rec_20260916_542f3c",
+      "reason": "superseded_or_not_current"
+    },
+    {
+      "record_id": "rec_20260916_790d63",
+      "reason": "superseded_or_not_current"
+    },
+    {
+      "record_id": "rec_20260916_eed51c",
+      "reason": "superseded_or_not_current"
+    },
+    {
+      "record_id": "rec_20260916_67181b",
+      "reason": "superseded_or_not_current"
+    },
+    {
+      "record_id": "rec_20260916_73173f",
+      "reason": "superseded_or_not_current"
+    },
+    {
+      "record_id": "rec_20260916_80ed3e",
+      "reason": "superseded_or_not_current"
+    },
+    {
+      "record_id": "rec_20260916_895d3e",
+      "reason": "superseded_or_not_current"
+    },
+    {
+      "record_id": "rec_20260916_d2e242",
+      "reason": "superseded_or_not_current"
+    },
+    {
+      "record_id": "rec_20260916_bc6308",
+      "reason": "superseded_or_not_current"
+    },
+    {
+      "record_id": "rec_20260916_942766",
+      "reason": "superseded_or_not_current"
+    },
+    {
+      "record_id": "rec_20260916_87de54",
+      "reason": "superseded_or_not_current"
+    },
+    {
+      "record_id": "rec_20260916_051afe",
+      "reason": "superseded_or_not_current"
+    },
+    {
+      "record_id": "rec_20260916_05ff1f",
+      "reason": "superseded_or_not_current"
+    },
+    {
+      "record_id": "rec_20260916_1bc779",
+      "reason": "superseded_or_not_current"
+    },
+    {
+      "record_id": "rec_20260916_600a8c",
+      "reason": "superseded_or_not_current"
+    },
+    {
+      "record_id": "rec_20260916_eed34c",
+      "reason": "superseded_or_not_current"
+    },
+    {
+      "record_id": "rec_20260916_6945d2",
+      "reason": "superseded_or_not_current"
+    },
+    {
+      "record_id": "rec_20260916_da339e",
+      "reason": "superseded_or_not_current"
+    },
+    {
+      "record_id": "rec_20260916_975962",
+      "reason": "superseded_or_not_current"
+    },
+    {
+      "record_id": "rec_20260914_f40469",
+      "reason": "no_eligible_claims"
+    },
+    {
+      "record_id": "rec_20260914_7cbf35",
+      "reason": "no_eligible_claims"
+    },
+    {
+      "record_id": "rec_20260914_dbb935",
+      "reason": "no_eligible_claims"
+    },
+    {
+      "record_id": "rec_20260916_72a97d",
+      "reason": "no_eligible_claims"
+    }
+  ],
+  "privacy_excluded": []
+}

schemas/claims.schema.json

@@ -0,0 +1,149 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "claim_id",
+    "claim_json",
+    "claim_type",
+    "conditions_json",
+    "created_at",
+    "creator",
+    "family",
+    "full_record_eligible",
+    "id",
+    "license",
+    "limitations",
+    "model",
+    "molecule_smiles",
+    "molecules_json",
+    "prediction_timing",
+    "property",
+    "question",
+    "record_id",
+    "source_capture_id",
+    "source_confidence_json",
+    "source_model",
+    "statement",
+    "tags",
+    "template_id",
+    "tier",
+    "tool",
+    "trust_factor",
+    "unit",
+    "validation_gates_json",
+    "value",
+    "value_json",
+    "verdict"
+  ],
+  "properties": {
+    "claim_id": {
+      "type": "string"
+    },
+    "claim_json": {
+      "type": "string"
+    },
+    "claim_type": {
+      "type": "string"
+    },
+    "conditions_json": {
+      "type": "string"
+    },
+    "created_at": {
+      "type": "string"
+    },
+    "creator": {
+      "type": "string"
+    },
+    "family": {
+      "type": "string"
+    },
+    "full_record_eligible": {
+      "type": "boolean"
+    },
+    "id": {
+      "type": "string"
+    },
+    "license": {
+      "type": "string"
+    },
+    "limitations": {
+      "type": "string"
+    },
+    "model": {
+      "type": "string"
+    },
+    "molecule_smiles": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "molecules_json": {
+      "type": "string"
+    },
+    "prediction_timing": {
+      "type": "string"
+    },
+    "property": {
+      "type": "string"
+    },
+    "question": {
+      "type": "string"
+    },
+    "record_id": {
+      "type": "string"
+    },
+    "source_capture_id": {
+      "type": "string"
+    },
+    "source_confidence_json": {
+      "type": "string"
+    },
+    "source_model": {
+      "type": "string"
+    },
+    "statement": {
+      "type": "string"
+    },
+    "tags": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "template_id": {
+      "type": "string"
+    },
+    "tier": {
+      "type": "integer"
+    },
+    "tool": {
+      "type": "string"
+    },
+    "trust_factor": {
+      "type": [
+        "null",
+        "number"
+      ]
+    },
+    "unit": {
+      "type": "string"
+    },
+    "validation_gates_json": {
+      "type": "string"
+    },
+    "value": {
+      "type": [
+        "null",
+        "number"
+      ]
+    },
+    "value_json": {
+      "type": "string"
+    },
+    "verdict": {
+      "type": "string"
+    }
+  }
+}

schemas/evidence.schema.json

@@ -0,0 +1,64 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "args_json",
+    "duration_ms",
+    "omitted_metadata_fields",
+    "public_row_json",
+    "request_id",
+    "response_json",
+    "row_sha256",
+    "source_capture_id",
+    "source_line",
+    "source_row_sha256",
+    "status",
+    "timestamp",
+    "tool"
+  ],
+  "properties": {
+    "args_json": {
+      "type": "string"
+    },
+    "duration_ms": {
+      "type": "integer"
+    },
+    "omitted_metadata_fields": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "public_row_json": {
+      "type": "string"
+    },
+    "request_id": {
+      "type": "string"
+    },
+    "response_json": {
+      "type": "string"
+    },
+    "row_sha256": {
+      "type": "string"
+    },
+    "source_capture_id": {
+      "type": "string"
+    },
+    "source_line": {
+      "type": "integer"
+    },
+    "source_row_sha256": {
+      "type": "string"
+    },
+    "status": {
+      "type": "string"
+    },
+    "timestamp": {
+      "type": "string"
+    },
+    "tool": {
+      "type": "string"
+    }
+  }
+}

schemas/records.schema.json

@@ -0,0 +1,160 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "answer",
+    "beginner_question",
+    "builder_review_recorded",
+    "claims_count",
+    "claims_json",
+    "created_at",
+    "creator",
+    "derived_questions_json",
+    "family",
+    "interpretations_json",
+    "ledger_entry",
+    "ledger_line",
+    "license",
+    "limitations",
+    "molecule_smiles",
+    "molecules_json",
+    "paraphrases",
+    "prediction_timing",
+    "question",
+    "record_id",
+    "referee_model",
+    "referee_score",
+    "related_record_ids",
+    "source_capture_id",
+    "source_confidence_json",
+    "source_model",
+    "source_record_sha256",
+    "source_trace_sha256",
+    "tags",
+    "template_id",
+    "tier",
+    "tool_calls_count",
+    "trace_markdown",
+    "validation_gates_json"
+  ],
+  "properties": {
+    "answer": {
+      "type": "string"
+    },
+    "beginner_question": {
+      "type": "string"
+    },
+    "builder_review_recorded": {
+      "type": "boolean"
+    },
+    "claims_count": {
+      "type": "integer"
+    },
+    "claims_json": {
+      "type": "string"
+    },
+    "created_at": {
+      "type": "string"
+    },
+    "creator": {
+      "type": "string"
+    },
+    "derived_questions_json": {
+      "type": "string"
+    },
+    "family": {
+      "type": "string"
+    },
+    "interpretations_json": {
+      "type": "string"
+    },
+    "ledger_entry": {
+      "type": "string"
+    },
+    "ledger_line": {
+      "type": "integer"
+    },
+    "license": {
+      "type": "string"
+    },
+    "limitations": {
+      "type": "string"
+    },
+    "molecule_smiles": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "molecules_json": {
+      "type": "string"
+    },
+    "paraphrases": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "prediction_timing": {
+      "type": "string"
+    },
+    "question": {
+      "type": "string"
+    },
+    "record_id": {
+      "type": "string"
+    },
+    "referee_model": {
+      "type": "string"
+    },
+    "referee_score": {
+      "type": [
+        "null",
+        "number"
+      ]
+    },
+    "related_record_ids": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "source_capture_id": {
+      "type": "string"
+    },
+    "source_confidence_json": {
+      "type": "string"
+    },
+    "source_model": {
+      "type": "string"
+    },
+    "source_record_sha256": {
+      "type": "string"
+    },
+    "source_trace_sha256": {
+      "type": "string"
+    },
+    "tags": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "template_id": {
+      "type": "string"
+    },
+    "tier": {
+      "type": "integer"
+    },
+    "tool_calls_count": {
+      "type": "integer"
+    },
+    "trace_markdown": {
+      "type": "string"
+    },
+    "validation_gates_json": {
+      "type": "string"
+    }
+  }
+}

test_release.py

@@ -0,0 +1,101 @@
+"""Regression checks for public-copy curation and provenance."""
+import copy
+import hashlib
+import json
+
+import pytest
+
+from build_dataset import clean_claim_ids, privacy_issues, public_tool_row, schema_for
+from verify import pointer, verify_evidence
+
+
+def canonical(value):
+    return json.dumps(value, sort_keys=True, separators=(",", ":"), ensure_ascii=False, allow_nan=False).encode()
+
+
+def example_row():
+    # Synthetic bookkeeping fixture, not a chemistry observation.
+    value = {"line": 7, "ts": "2026-09-17T00:00:00Z", "duration_ms": 1,
+             "tool": "fixture_tool", "args": {"smiles": "C", "properties": ["fixture"]},
+             "request_id": "fixture-request", "status": "ok",
+             "request": {"id": 1, "jsonrpc": "2.0", "method": "tools/call",
+                         "params": {"name": "fixture_tool", "arguments": {"smiles": "C", "properties": ["fixture"]},
+                                    "_meta": {"workspaces": {"/home/example/private": {"session": "not-public"}}}}},
+             "response": {"jsonrpc": "2.0", "id": 1, "result": {
+                 "_meta": {"request_id": "fixture-request", "model_version": "fixture-v1"},
+                 "structuredContent": {"number": 1.25, "trust_factor": 75.5}}}}
+    value["sha256"] = hashlib.sha256(canonical(value)).hexdigest()
+    return value
+
+
+def public_projection():
+    original = example_row()
+    public, removed = public_tool_row(original)
+    return original, public, {
+        "request_id": public["request_id"], "tool": public["tool"], "status": public["status"],
+        "timestamp": public["ts"], "duration_ms": public["duration_ms"], "source_line": public["line"],
+        "row_sha256": public["sha256"], "source_row_sha256": original["sha256"],
+        "omitted_metadata_fields": removed, "args_json": json.dumps(public["args"]),
+        "response_json": json.dumps(public["response"]), "public_row_json": json.dumps(public),
+    }
+
+
+def test_projection_removes_only_client_metadata():
+    original = example_row()
+    before = copy.deepcopy(original)
+    public, removed = public_tool_row(original)
+    assert original == before
+    assert public["args"] == original["args"]
+    assert public["response"] == original["response"]
+    assert public["response"]["result"]["_meta"]["request_id"] == "fixture-request"
+    assert removed == ["request.params._meta"]
+    assert public["sha256"] != original["sha256"]
+    assert not privacy_issues(public)
+    assert privacy_issues(original)
+
+
+def test_public_evidence_hash_checks_the_response():
+    original, public, exported = public_projection()
+    verify_evidence(exported)
+    public["response"]["result"]["structuredContent"]["number"] = 2.5
+    exported["response_json"] = json.dumps(public["response"])
+    exported["public_row_json"] = json.dumps(public)
+    with pytest.raises(AssertionError, match="hash"):
+        verify_evidence(exported)
+
+
+def test_flat_argument_column_cannot_disagree_with_public_row():
+    _, _, exported = public_projection()
+    exported["args_json"] = json.dumps({"smiles": "CC"})
+    with pytest.raises(AssertionError, match="Arguments"):
+        verify_evidence(exported)
+
+
+def test_passed_arithmetic_does_not_override_ineligible_sources():
+    record = {"claims": [{"id":"primary", "verdict":"inconclusive"},
+                         {"id":"arithmetic", "verdict":"passed"},
+                         {"id":"independent", "verdict":"passed"}]}
+    confidence = {"primary":{"context_eligible":False},
+                  "arithmetic":{"context_eligible":False},
+                  "independent":{"context_eligible":True}}
+    assert clean_claim_ids(record,confidence) == {"independent"}
+
+
+def test_schema_supports_nullable_scalars_and_rejects_shape_drift():
+    schema = schema_for([{"value":None,"tags":[]}, {"value":1.0,"tags":["low-trust"]}])
+    assert schema["properties"]["value"]["type"] == ["null","number"]
+    with pytest.raises(ValueError, match="columns"):
+        schema_for([{"value":1}, {"unexpected":1}])
+
+
+def test_pointer_decodes_nested_response_text_and_escaped_keys():
+    response = {"result":{"content":[{"text":json.dumps({"a/b":{"~key":1.25}})}]}}
+    assert pointer(response,"/result/content/0/text/a~1b/~0key") == 1.25
+    with pytest.raises(KeyError):
+        pointer(response,"/result/absent")
+
+
+def test_secret_scan_checks_dictionary_keys_as_well_as_values():
+    assert privacy_issues({"workspaces":{"/home/example/private":{}}})
+    assert privacy_issues("gh" + "p_" + "x"*40)
+    assert not privacy_issues({"request_id":"fixture-request","model":"recorded-model"})

upload.py

@@ -0,0 +1,38 @@
+"""Upload only the verified public files to a named Hugging Face dataset."""
+import argparse
+import os
+from pathlib import Path
+import sys
+
+sys.dont_write_bytecode = True
+ROOT = Path(__file__).resolve().parent
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--repo-id", required=True, help="Your organization/dataset-name")
+    parser.add_argument("--private", action="store_true", help="Create a new repository as private")
+    args = parser.parse_args()
+    if "/" not in args.repo_id or args.repo_id.startswith("YOUR_ORG/"):
+        parser.error("Supply your actual organization and dataset name.")
+    if not os.environ.get("HF_TOKEN"):
+        parser.error("Supply HF_TOKEN through your environment.")
+    from verify import verify
+    manifest = verify(ROOT)
+    os.environ.setdefault("HF_HOME", str(ROOT / ".cache/huggingface"))
+    try:
+        from huggingface_hub import HfApi
+    except ImportError:
+        parser.error("The optional uploader requires the official huggingface_hub package.")
+    api = HfApi(token=os.environ["HF_TOKEN"])
+    api.create_repo(args.repo_id, repo_type="dataset", private=args.private, exist_ok=True)
+    result = api.upload_folder(
+        repo_id=args.repo_id, repo_type="dataset", folder_path=str(ROOT),
+        allow_patterns=sorted([*manifest["files"], "manifest.json", "SHA256SUMS"]),
+        commit_message="Release ChemBricks curated knowledge " + manifest["release_version"],
+    )
+    print(result.commit_url)
+
+
+if __name__ == "__main__":
+    main()

verification.json

@@ -0,0 +1,50 @@
+{
+  "python": "3.13.12",
+  "datasets": "5.0.1",
+  "huggingface_hub": "1.31.0",
+  "network_for_data_loading": "disabled",
+  "dataset_card": "pass",
+  "regression_tests": {
+    "passed": 7
+  },
+  "configurations": {
+    "records": {
+      "rows": 346,
+      "columns": 34,
+      "first_row_round_trip": "pass",
+      "status": "pass",
+      "all_rows_round_trip": "pass"
+    },
+    "claims": {
+      "rows": 6665,
+      "columns": 32,
+      "first_row_round_trip": "pass",
+      "status": "pass",
+      "all_rows_round_trip": "pass"
+    },
+    "evidence": {
+      "rows": 8001,
+      "columns": 13,
+      "first_row_round_trip": "pass",
+      "status": "pass",
+      "all_rows_round_trip": "pass"
+    }
+  },
+  "figure": {
+    "status": "rendered",
+    "svg": "assets/knowledge-path.svg",
+    "png": "assets/knowledge-path.png",
+    "renderer": "CairoSVG 2.9.1",
+    "width": 3080,
+    "height": 1140,
+    "source_svg_sha256": "8a51ce3b0b654cd6d7bc299322ff26fb85b191d064db7c5a70257138c26d5f3e",
+    "visual_review": "Seven stages, labels, captions and feedback arrow checked at page-sized resolution; no clipping observed."
+  },
+  "data_sha256": {
+    "records": "05f65efd63d71eef4f37ce53af1192166958d6d22dba8d21e15e67efa1ff71f6",
+    "claims": "a73b2b613f39413f8b4f8ecdd820529e15c555cb1861096c81a26178938a90e3",
+    "evidence": "3947b3e568526821c9689e84737cc29dadbe8aa766aa536512e75de761188c37"
+  },
+  "card_metadata_sha256": "19601634a77a01278a65e6a5496357c948a00e1ca4d5758ee1a73bd0f867bae6",
+  "publication": "prepublication_checks_only"
+}

verify.py

@@ -0,0 +1,193 @@
+"""Verify or seal the distributable dataset without contacting any service."""
+from __future__ import annotations
+import argparse
+import hashlib
+import json
+from pathlib import Path
+import re
+import sys
+
+sys.dont_write_bytecode = True
+ROOT = Path(__file__).resolve().parent
+TOP_FILES = {"README.md", "LICENSE", "CURATION.md", "DATA_DICTIONARY.md", "UPLOAD.md",
+             "CITATION.cff", "build_dataset.py", "write_card.py", "verify.py", "upload.py",
+             "test_release.py", "verification.json", ".gitignore"}
+PUBLIC_DIRS = {"data", "assets", "schemas", "provenance", "examples"}
+SECRET = re.compile(r"\b(?:github_pat_[A-Za-z0-9_]{30,}|gh[pousr]_[A-Za-z0-9]{30,}|hf_[A-Za-z0-9]{25,}|sk-(?:ant-|proj-)?[A-Za-z0-9_-]{24,})\b|-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----")
+PRIVATE = re.compile(r"/home/[A-Za-z0-9_.-]+/|https?://[^\s\"<>]*\.ts\.net\b")
+
+
+def digest(raw):
+    return hashlib.sha256(raw).hexdigest()
+
+
+def canonical(value):
+    return json.dumps(value, sort_keys=True, separators=(",", ":"), ensure_ascii=False, allow_nan=False).encode()
+
+
+def read_rows(path):
+    with path.open(encoding="utf-8") as stream:
+        return [json.loads(line) for line in stream if line.strip()]
+
+
+def pointer(value, path):
+    if path in ("", "$"):
+        return value
+    parts = path[1:].split("/") if path.startswith("/") else path.removeprefix("$.").split(".")
+    for part in parts:
+        if isinstance(value, str):
+            value = json.loads(value)
+        part = part.replace("~1", "/").replace("~0", "~")
+        value = value[int(part)] if isinstance(value, list) else value[part]
+    return value
+
+
+def references(value):
+    if isinstance(value, dict):
+        if isinstance(value.get("request_id"), str) and isinstance(value.get("path"), str):
+            yield value
+        for child in value.values():
+            yield from references(child)
+    elif isinstance(value, list):
+        for child in value:
+            yield from references(child)
+
+
+def verify_evidence(row):
+    public = json.loads(row["public_row_json"])
+    assert digest(canonical({k:v for k,v in public.items() if k != "sha256"})) == row["row_sha256"] == public["sha256"], "Public tool-row hash mismatch"
+    assert public["args"] == json.loads(row["args_json"]), "Arguments differ"
+    assert public["response"] == json.loads(row["response_json"]), "Response differs"
+    for key, other in [("request_id","request_id"),("tool","tool"),("status","status"),("line","source_line"),("ts","timestamp"),("duration_ms","duration_ms")]:
+        assert public[key] == row[other], "Evidence projection differs: " + key
+    assert re.fullmatch("[0-9a-f]{64}", row["source_row_sha256"]), "Invalid source row hash"
+    request = public.get("request", {})
+    assert not any(k in request or k in request.get("params", {}) for k in ("_meta", "meta", "metadata")), "Client metadata was retained"
+    assert not SECRET.search(row["public_row_json"]) and not PRIVATE.search(row["public_row_json"]), "Private evidence content"
+    return public
+
+
+def manifest_files(root):
+    files = []
+    for path in sorted(root.rglob("*")):
+        relative = path.relative_to(root)
+        if not path.is_file() or path.is_symlink():
+            continue
+        if (len(relative.parts) == 1 and relative.name in TOP_FILES) or relative.parts[0] in PUBLIC_DIRS:
+            if "__pycache__" not in relative.parts and path.suffix != ".pyc":
+                files.append(path)
+    return files
+
+
+def seal(root=ROOT):
+    root = Path(root).resolve()
+    assert root == ROOT or root.is_relative_to(ROOT), "Seal output must remain inside huggingface/"
+    manifest = json.loads((root / "manifest.json").read_text())
+    manifest["files"] = {str(p.relative_to(root)): {"sha256":digest(p.read_bytes()), "bytes":p.stat().st_size} for p in manifest_files(root)}
+    (root / "manifest.json").write_text(json.dumps(manifest, ensure_ascii=True, allow_nan=False, indent=2) + "\n")
+    names = [*manifest["files"], "manifest.json"]
+    (root / "SHA256SUMS").write_text("".join(digest((root/name).read_bytes()) + "  " + name + "\n" for name in sorted(names)))
+    return manifest
+
+
+def verify(root=ROOT):
+    from jsonschema import Draft202012Validator
+    root = Path(root).resolve()
+    manifest = json.loads((root / "manifest.json").read_text())
+    assert manifest["license"] == "mit" and manifest["created_by"] == "ChemBricks"
+    for name, item in manifest["files"].items():
+        path = (root / name).resolve()
+        assert path.is_relative_to(root) and not (root / name).is_symlink()
+        assert digest(path.read_bytes()) == item["sha256"] and path.stat().st_size == item["bytes"], "File differs: " + name
+    sums = {}
+    for line in (root / "SHA256SUMS").read_text().splitlines():
+        expected, name = line.split("  ", 1)
+        assert name in manifest["files"] or name == "manifest.json", "Unexpected checksum path"
+        assert name not in sums, "Duplicate checksum path"
+        assert digest((root/name).read_bytes()) == expected, "Checksum differs: " + name
+        sums[name] = expected
+    assert set(sums) == set(manifest["files"]) | {"manifest.json"}
+    data = {}
+    for name in ("records", "claims", "evidence"):
+        schema = json.loads((root / "schemas" / (name + ".schema.json")).read_text())
+        validator = Draft202012Validator(schema)
+        data[name] = read_rows(root / "data" / (name + ".jsonl"))
+        for row in data[name]:
+            validator.validate(row)
+            serialized = json.dumps(row)
+            assert not SECRET.search(serialized) and not PRIVATE.search(serialized), "Private material in " + name
+        expected = manifest["evidence_rows" if name == "evidence" else name]
+        assert len(data[name]) == expected, "Count differs: " + name
+    by_call = {}
+    for row in data["evidence"]:
+        key = row["source_capture_id"], row["request_id"]
+        assert key not in by_call, "Duplicate evidence join key"
+        by_call[key] = verify_evidence(row)
+    provenance = {row["record_id"]: row for row in read_rows(root / "provenance/records.jsonl")}
+    ledger_raw = (root / "provenance/source-ledger.jsonl").read_bytes()
+    assert digest(ledger_raw) == manifest["source_ledger_sha256"]
+    chain = read_rows(root / "provenance/source-ledger.jsonl")
+    previous, ledger = "0" * 64, {}
+    for i, row in enumerate(chain, 1):
+        assert row["prev"] == previous and row["record_id"] not in ledger
+        assert digest((row["record_sha256"] + row["tools_sha256"] + row["trace_sha256"] + previous).encode()) == row["entry"]
+        previous = row["entry"]
+        ledger[row["record_id"]] = (i,row)
+    assert previous == manifest["source_ledger_head"] and len(chain) == manifest["source_ledger_entries"]
+    for rid, source in provenance.items():
+        assert (source["ledger_line"],source["ledger"]) == ledger[rid]
+        assert source["release_license"] == "mit"
+    claim_index = {}
+    for row in data["claims"]:
+        key = row["record_id"], row["claim_id"]
+        assert key not in claim_index and row["id"] == ":".join(key)
+        claim = json.loads(row["claim_json"])
+        confidence = json.loads(row["source_confidence_json"])
+        assert claim["verdict"] == row["verdict"] == "passed"
+        assert confidence["context_eligible"] and not confidence["issues"] and confidence["prediction_timing"] != "fail"
+        assert all(s["verdict"] == "passed" and not s["quarantined"] for s in confidence["sources"])
+        assert row["statement"] == claim["statement"] and row["value_json"] == json.dumps(claim.get("value"),sort_keys=True,separators=(",",":"))
+        assert row["license"] == "mit" and row["creator"] == "ChemBricks"
+        assert row["source_capture_id"] == provenance[row["record_id"]]["ledger"]["tools_sha256"]
+        for ref in references([claim, confidence]):
+            source = by_call[(row["source_capture_id"], ref["request_id"])]
+            pointer(source["response"], ref["path"])
+        claim_index[key] = row
+    seen = set()
+    for row in data["records"]:
+        rid = row["record_id"]
+        assert rid not in seen
+        seen.add(rid)
+        source = provenance[rid]
+        assert source["full_record_eligible"] and source["ledger"]["record_sha256"] == row["source_record_sha256"]
+        assert digest(row["trace_markdown"].encode()) == source["ledger"]["trace_sha256"] == row["source_trace_sha256"]
+        assert row["source_capture_id"] == source["ledger"]["tools_sha256"]
+        assert row["license"] == "mit" and row["creator"] == "ChemBricks"
+        claims = json.loads(row["claims_json"])
+        assert len(claims) == row["claims_count"]
+        assert json.loads(row["validation_gates_json"])["G6"] == "pass"
+        for claim in claims:
+            exported = claim_index[(rid,claim["id"])]
+            assert exported["full_record_eligible"] and json.loads(exported["claim_json"]) == claim
+        confidence = json.loads(row["source_confidence_json"])
+        assert all(item["context_eligible"] for item in confidence.values())
+    assert all(row["full_record_eligible"] == (row["record_id"] in seen) for row in data["claims"])
+    card = (root / "README.md").read_text()
+    metadata = json.loads(card.split("---",2)[1])
+    assert metadata["license"] == "mit" and metadata["language"] == ["en"]
+    assert {c["config_name"] for c in metadata["configs"]} == set(data)
+    for config in metadata["configs"]:
+        assert config["data_files"] == [{"split":"corpus","path":"data/" + config["config_name"] + ".jsonl"}]
+    assert "assets/knowledge-path.svg" in card and "https://chembricks.ai" in card and "https://cmbx.ai" in card
+    assert "MIT License" in (root / "LICENSE").read_text()
+    print(json.dumps({"status":"pass","records":len(data["records"]),"claims":len(data["claims"]),"evidence_rows":len(data["evidence"]),"files":len(manifest["files"])}))
+    return manifest
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--seal", action="store_true")
+    args = parser.parse_args()
+    if args.seal:
+        seal()
+    verify()

write_card.py

@@ -0,0 +1,197 @@
+"""Write the dataset card from the measured release manifest."""
+import argparse
+import json
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent
+
+
+def write_card(repo_id="chembricks/chemistry-knowledge"):
+    manifest = json.loads((ROOT / "manifest.json").read_text())
+    records = [json.loads(line) for line in (ROOT / "data/records.jsonl").read_text().splitlines()]
+    metadata = {
+        "pretty_name": "ChemBricks Knowledge: Evidence-Linked Chemistry",
+        "license": "mit", "language": ["en"],
+        "task_categories": ["question-answering", "text-generation"],
+        "tags": ["chemistry", "computational-chemistry", "scientific-reasoning", "tool-use", "provenance", "synthetic", "text"],
+        "annotations_creators": ["machine-generated"],
+        "language_creators": ["machine-generated"],
+        "size_categories": ["1K<n<10K"],
+        "configs": [{"config_name": name, **({"default":True} if name=="records" else {}),
+                     "data_files":[{"split":"corpus","path":"data/"+name+".jsonl"}]}
+                    for name in ("records","claims","evidence")],
+    }
+    family_names = {"A":"Facts and molecular properties", "B":"Chemical series", "C":"Comparisons and counterfactuals",
+                    "D":"Reactions", "E":"Molecule design and discovery tasks", "F":"Method limits", "K":"Class hypotheses"}
+    family_table = "\n".join("| " + family + " | " + family_names.get(family[:1],family) + " | " + str(count) + " |"
+                              for family,count in manifest["family_counts"].items())
+    source_count = manifest["source_records_with_eligible_claims"]
+    sample = next((r for r in records if "caffeine" in r["question"].lower()), records[0])
+    text = f"""# ChemBricks Knowledge
+
+**Does caffeine prefer water or an oil-like liquid?**  
+**Why can adding one small group change a molecule's behavior?**  
+**Can we design a molecule that interacts more favorably with water while meeting other constraints?**  
+**How much energy does it take to remove an electron from a molecule?**
+
+These are the kinds of questions behind this dataset. Each investigation connects a question to recorded calculations, an answer, and the evidence needed to examine that answer.
+
+Created and curated by **[ChemBricks](https://chembricks.ai)** using our **[ChemBricks AI platform](https://cmbx.ai)**.
+
+![Physics, models, tools, questions, claims, checks and reusable context, with a feedback loop from checks to questions](assets/knowledge-path.png)
+
+[Download the vector figure](assets/knowledge-path.svg).
+
+*Physics informs the models; questions guide the calculations; checks determine which claims can become reusable context. The workflow also includes empirical descriptors and semiempirical methods, identified by their actual tool and model. The figure is a workflow schematic, not a claim that every row was independently validated by a high-level reference calculation.*
+
+## What you get
+
+This release contains **{manifest['records']:,} complete curated investigations**, **{manifest['claims']:,} eligible claims**, and **{manifest['evidence_rows']:,} recorded tool-call pairs**.
+
+The claim subset draws from **{source_count:,} source investigations**. It includes usable findings from investigations whose complete traces contain a disputed, failed, inconclusive or range-quarantined claim. Those full traces are excluded from the default records subset. The evidence table preserves intermediate observations, including failures; an evidence row is not itself a validated claim.
+
+| Configuration | Rows | Contents |
+|---|---:|---|
+| records, default | {manifest['records']:,} | Questions, answers, scientific audit trails, molecule identities, all claims and their qualifications |
+| claims | {manifest['claims']:,} | Individually eligible findings with methods, conditions, checks and evidence links |
+| evidence | {manifest['evidence_rows']:,} | Chemical arguments and returned responses, with original request IDs and provenance |
+
+All three configurations use the split **corpus**. This is an unsplit release, not an independent evaluation benchmark.
+
+Snapshot: **{manifest['snapshot_started_at']}**. Release: **{manifest['release_version']}**. The snapshot considered {manifest['current_records_considered']:,} current records from a ledger of {manifest['source_ledger_entries']:,} entries. It contains {manifest['distinct_tool_captures']:,} distinct source captures across the claim/evidence release. Multiple records sharing a capture are not separate simulations.
+
+## A familiar example
+
+One included investigation is **{sample['record_id']}**:
+
+> {sample['beginner_question']}
+
+Open its row to see the recorded answer, methods, conditions and Limitations section. Numerical results remain attached to their tool evidence. In the partition questions, the oil-like reference liquid is **octanol**. The computed quantity is logP for the recorded molecular form, not a direct measurement of how much material dissolves in water.
+
+## Read a record
+
+Load this dataset from [Hugging Face](https://huggingface.co/datasets/{repo_id}):
+
+\x60\x60\x60python
+from datasets import load_dataset
+
+records = load_dataset("{repo_id}", "records", split="corpus")
+print(records[0]["question"])
+print(records[0]["answer"])
+print(records[0]["limitations"])
+\x60\x60\x60
+
+For a local copy, run from this dataset directory:
+
+\x60\x60\x60python
+from datasets import load_dataset
+
+records = load_dataset(
+    "json",
+    data_files={{"corpus": "data/records.jsonl"}},
+    split="corpus",
+    cache_dir=".cache/datasets",
+)
+\x60\x60\x60
+
+The data also works with ordinary Python. See [examples/read_dataset.py](examples/read_dataset.py).
+
+## Follow a claim to its evidence
+
+\x60\x60\x60python
+import json
+from datasets import load_dataset
+
+claims = load_dataset("{repo_id}", "claims", split="corpus")
+evidence = load_dataset("{repo_id}", "evidence", split="corpus")
+
+item = claims[0]
+claim = json.loads(item["claim_json"])
+reference = claim["evidence"][0]
+call = next(
+    row for row in evidence
+    if row["source_capture_id"] == item["source_capture_id"]
+    and row["request_id"] == reference["request_id"]
+)
+response = json.loads(call["response_json"])
+print(item["statement"])
+print(item["conditions_json"])
+print(reference["path"])
+print(response)
+\x60\x60\x60
+
+Columns ending in **_json** contain JSON strings so varying scientific structures load consistently in the dataset viewer. [DATA_DICTIONARY.md](DATA_DICTIONARY.md) describes the columns and JSON-path convention.
+
+## How the data was created
+
+A question specifies molecules, methods, constraints and a budget. An isolated AI worker calls ChemBricks tools through a logging proxy and writes a scientific audit trail. Mechanical gates check schema, safety-screen completion, number provenance, methods, ranges, cross-checks and trust tags. Phase 1 uses an independent model referee and sampled replay checks. Accepted source records enter a hash-chained ledger.
+
+For this release, the original evidence hashes and mechanical checks were verified again offline. Applicable referee and replay evidence were checked. Arithmetic claims inherit the confidence limits of their source claims; a passed calculator result cannot upgrade an unresolved source.
+
+The default records subset requires every claim to qualify. This release includes {manifest['referee_reviewed_full_records']:,} full records with a passing independent model referee and {manifest['builder_reviewed_full_records']:,} with a matching recorded building-agent trace review. These counts overlap. Building-agent review is AI review, not an independent human annotation. Historical Phase 0 records retain their original gate states.
+
+The original question, answer, scientific trace, numerical claims and chemical responses are not scientifically rewritten during packaging. Local client metadata is removed from public request envelopes. [CURATION.md](CURATION.md) explains selection, privacy transformations and provenance.
+
+## Coverage
+
+| Family | Question type | Complete records |
+|---|---|---:|
+{family_table}
+
+The complete-record subset covers {manifest['molecules_in_full_records']:,} distinct canonical molecule strings in its recorded registries. This is a deliberately selected corpus of molecular properties, comparisons and design studies, not a representative sample of all chemical space. Paraphrases, related molecules and derived questions introduce substantial dependence.
+
+## What verified means here
+
+Verified means **traceable to the recorded computation and checked under its declared policy**. It does not mean experimentally established truth.
+
+- Predictions retain their actual model, conditions, applicability and trust information. A high tool trust factor is not a calibrated experimental confidence probability.
+- Cross-route comparisons can support consistency without proving a mechanism or supplying an experimental error bar.
+- Interpretations are distinguished from measurements. A missing descriptor cannot establish a proposed causal explanation.
+- Some historical traces have unverified pre-call prediction timing. Their comparisons remain descriptive. The prediction_timing column preserves this distinction.
+- Low-trust and screening-grade results retain their tags. A passed claim can still have a limited domain of use.
+- Model-based designs are tested computational proposals. They do not establish synthesis, laboratory safety, availability, novelty, or broad chemical laws.
+- The underlying model-training datasets, model weights and full high-level simulation trajectories are not included. This release contains the recorded outputs and knowledge-building investigations.
+
+## Intended uses and evaluation limits
+
+Use the corpus to study evidence-grounded chemistry assistance, retrieve qualified computational context, inspect tool use, or develop scientific question-answering systems. Retain methods, uncertainty, limitations and provenance when constructing a downstream example.
+
+No frozen scaffold holdout exists in the source snapshot. Before training and evaluation, define and document one that keeps linked records, shared captures, generated candidates and scaffold-related molecules from leaking across partitions. The claims and evidence subsets are alternate views of the same source material, not independent datasets.
+
+## Integrity and release files
+
+Run **python -B verify.py** with Python 3.11+ and jsonschema to verify file checksums, public schemas, the ledger commitment chain, preserved trace hashes, claim eligibility and evidence links.
+
+[manifest.json](manifest.json) records the exact source state, counts, code hashes and transformations. [SHA256SUMS](SHA256SUMS) covers the distributable files. The provenance directory retains source hashes and selection decisions. See [UPLOAD.md](UPLOAD.md) for publishing instructions.
+
+## Creators, license and citation
+
+**Creator and publisher:** ChemBricks  
+**Company:** [chembricks.ai](https://chembricks.ai)  
+**AI platform:** [cmbx.ai](https://cmbx.ai)  
+**License:** [MIT](LICENSE), copyright 2026 ChemBricks
+
+This release's curated data, documentation and figure are released under MIT at the dataset owner's direction. Historical source license labels are retained only in the provenance index. They describe the source records' earlier metadata.
+
+\x60\x60\x60bibtex
+@misc{{chembricks_knowledge_2026,
+  author = {{{{ChemBricks}}}},
+  title = {{ChemBricks Knowledge: Evidence-Linked Chemistry Questions and Claims}},
+  year = {{2026}},
+  version = {{{manifest['release_version']}}},
+  url = {{https://huggingface.co/datasets/{repo_id}}}
+}}
+\x60\x60\x60
+
+[CITATION.cff](CITATION.cff) provides machine-readable citation metadata. Include the Hub revision when citing a particular snapshot; no DOI or associated paper is claimed.
+
+Dataset layout follows the [Hugging Face dataset-card specification](https://huggingface.co/docs/hub/datasets-cards) and [data-file configuration](https://huggingface.co/docs/hub/datasets-data-files-configuration).
+"""
+    (ROOT / "README.md").write_text("---\n" + json.dumps(metadata, indent=2) + "\n---\n\n" + text)
+    print(json.dumps({"card":"README.md","repository_example":repo_id,"records":manifest["records"]}))
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--repo-id", default="chembricks/chemistry-knowledge")
+    write_card(parser.parse_args().repo_id)