docs: link to Hugging Face model repo (cahlen/keeloq-neural-distinguishers)

- README.md: new "Pre-trained distinguishers on Hugging Face" section with
  the checkpoint availability table and one-liner `hf download` example.
- CLAUDE.md: checkpoint policy rewritten to describe the git-+-HF dual
  mirror and the commands future sessions should run when producing a new
  checkpoint (train, evaluate, upload with the metric summary).

Hub URL: https://huggingface.co/cahlen/keeloq-neural-distinguishers
d64.pt is live (val acc 0.752, ROC-AUC 0.828); d96/d128 land when training
finishes.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: cahlen

CLAUDE.md

@@ -57,11 +57,26 @@ The core nonlinear function is shared across cipher, ANF generator, and GPU ciph
 
 On the CLI these are `--diff-pair` and `--sat-pair` respectively (both repeatable). Conflating them is a category error; early drafts of the test suite hit this and the fix was to split the API.
 
-**Checkpoint policy.** `checkpoints/` is not committed by default. Produce a checkpoint with:
+**Checkpoint policy.** Large binary checkpoints are *not* committed to this git repo (they would bloat clones). Instead they are:
 
+1. Committed to the git repo anyway when small (d64.pt is 11.8 MB — fine). Whether to commit larger checkpoints is a case-by-case call; the HF mirror is always authoritative.
+2. Mirrored to Hugging Face at [`cahlen/keeloq-neural-distinguishers`](https://huggingface.co/cahlen/keeloq-neural-distinguishers) with a model card covering training config, eval metrics, architecture, and attack procedure.
+
+**When you produce a new checkpoint**, update both locations:
+
+    # Train
     uv run keeloq neural auto --rounds 64 --trained-depth 56 \
         --samples 10000000 --pairs 512 --checkpoint-out checkpoints/d64.pt
 
+    # Evaluate (appends to the per-depth JSON report)
+    uv run keeloq neural evaluate --checkpoint checkpoints/d64.pt \
+        --rounds 56 --samples 1000000 --seed 4242 \
+        > docs/phase3b-results/eval_d64.json
+
+    # Upload to HF (update the README.md table in the HF repo with the new metrics)
+    hf upload cahlen/keeloq-neural-distinguishers checkpoints/d64.pt d64.pt \
+        --commit-message "d64.pt: <summary of result>"
+
 The regression test `tests/test_neural_e2e_64r.py` auto-skips when `checkpoints/d64.pt` is absent. The benchmark runner (`benchmarks/bench_neural.py`) reports `SKIP_MISSING_CHECKPOINT` rather than crashing on missing checkpoints — it's smoke-safe.
 
 ## Red flags when editing

README.md

@@ -50,7 +50,12 @@ End-to-end, one command (Δ search + train + attack a synthetic target):
         --samples 10000000 --pairs 512 \
         --checkpoint-out checkpoints/d64.pt
 
-~30 minutes training time on an RTX 5090. Afterwards, attack any new ciphertext under the same key:
+~60 minutes training time on an RTX 5090. Or skip training and pull a published checkpoint from Hugging Face:
+
+    mkdir -p checkpoints
+    hf download cahlen/keeloq-neural-distinguishers d64.pt --local-dir checkpoints/
+
+Then attack any new ciphertext under the same key:
 
     uv run keeloq neural recover-key --checkpoint checkpoints/d64.pt \
         --rounds 64 --diff-pair "<c0>:<c1>" --sat-pair "<pt>:<ct>" \
@@ -64,6 +69,18 @@ A ResNet-1D-CNN distinguisher is trained at a fixed depth **D** (e.g. 56) to sep
 
 **Key-schedule constraint.** KeeLoq's key cycles every 64 rounds; at fewer than 64 rounds, bits `K_rounds..K_63` are never referenced and can't be recovered without being hinted. Attacks below 64 rounds therefore auto-populate `extra_key_hints` for the unconstrained range — handled automatically by `keeloq neural auto`.
 
+### Pre-trained distinguishers on Hugging Face
+
+Checkpoints are published at [**cahlen/keeloq-neural-distinguishers**](https://huggingface.co/cahlen/keeloq-neural-distinguishers) with a full model card covering training config, eval metrics, architecture, and attack procedure. Current availability:
+
+| File | Trained Depth | Attack Target | Val Accuracy | ROC-AUC |
+|---|---:|---:|---:|---:|
+| `d64.pt` | 56 | 64 rounds | 0.752 | 0.828 |
+| `d96.pt` | 88 | 96 rounds | (coming) | (coming) |
+| `d128.pt` | 120 | 128 rounds | (coming) | (coming) |
+
+Each `.pt` file embeds its full `TrainingConfig`, so results are reproducible from seed alone.
+
 ## Pipeline composition via Unix pipes
 
 The algebraic pipeline is also exposed as discrete stages with JSON on stdin/stdout: