Clarify proof-of-concept status: circuit validation complete, LLM integration in progress

Renamed passthrough training files to reflect their scaffolding role:
- train.py → train_passthrough.py
- train_router.py → train_passthrough_router.py
- trained_router.pt → trained_passthrough_router.pt

These demonstrate routing works with pre-formatted inputs, but the real
challenge is learning to extract operands from LLM hidden states.

Updated README:
- Stage 1 (Circuit Validation): COMPLETE - 100% on all ops
- Stage 2 (LLM Baseline): COMPLETE - SmolLM2 at 11.90%
- Stage 3 (LLM Integration): IN PROGRESS - the actual hard part

Honest assessment: passthrough training is trivial (copies labels).
Real test is parsing "47 + 86" from hidden states, not [bits, op_onehot].

README.md

@@ -503,58 +503,59 @@ The experimental condition adds:
 2. Neural interface layers can learn to use discrete computational substrates
 3. Small language models can achieve perfect arithmetic via architectural augmentation rather than scale
 
-#### Proof of Concept Results
+#### Progress
 
-**VALIDATED.** Frozen threshold circuits + trained router achieve 100% arithmetic accuracy.
+**Stage 1: Circuit Validation — COMPLETE**
 
-| Configuration | Fitness | Trainable Params | Training Time |
-|---------------|---------|------------------|---------------|
-| Vanilla SmolLM2-360M | 11.90% | 0 (inference only) | — |
-| DirectCircuitModel (frozen circuits, ground truth bits) | 100.00% | 0 | — |
-| Frozen Circuits + Trained Router | **100.00%** | **1,862** | **1 epoch (~10s)** |
+The frozen threshold circuits achieve 100% accuracy when given correctly formatted bit inputs:
+
+| Test | Result |
+|------|--------|
+| DirectCircuitModel (ground truth bits) | 100.00% on 10,000 random cases |
+| All operations (ADD, SUB, MUL, GT, LT, EQ) | 100.00% each |
+
+This confirms the circuits compute correctly. However, this was already established by `eval.py`.
+
+**Stage 2: LLM Baseline — COMPLETE**
+
+SmolLM2-360M-Instruct baseline on randomized 8-bit arithmetic:
+
+| Operation | Accuracy |
+|-----------|----------|
+| Addition | 35.92% |
+| Subtraction | 17.72% |
+| Multiplication | 1.25% |
+| Comparisons | 0.28–14.37% |
+| **Overall** | **11.90%** |
+
+Head-to-head on 50 random cases: SmolLM2 got 7/50 (14%), circuits got 50/50 (100%).
+
+**Stage 3: LLM Integration — IN PROGRESS**
+
+The actual challenge: train an interface that extracts operands and operations from LLM hidden states (not from pre-formatted bit inputs).
 
 ```
-======================================================================
- ROUTER-ONLY TRAINING (Ground Truth Bits)
-======================================================================
-Router parameters: 1,862
-Initial fitness: 0.1780
-
-Training...
-----------------------------------------------------------------------
-Epoch   1 | Loss: 0.0731 | Fitness: 1.0000 * | Time: 10.2s
-
- TARGET: 100% FITNESS ACHIEVED
-
-Per-operation:
-  add: 1.0000
-  sub: 1.0000
-  mul: 1.0000
-  gt: 1.0000
-  lt: 1.0000
-  eq: 1.0000
-
-CONCLUSION: Router successfully learned operation dispatch.
-           With correct bit encoding, 100% is achievable.
-======================================================================
+"What is 47 + 86?"
+    ↓
+[LLM hidden states]
+    ↓
+BitExtractor (must LEARN: "47" → 00101111, "86" → 01010110)
+OpRouter (must LEARN: "+" → add operation)
+    ↓
+[Frozen threshold circuits]
+    ↓
+[Result bits] → "133"
 ```
 
-**Key findings:**
-1. Frozen threshold circuits achieve 100% on all operations when given correct bit inputs
-2. A 1,862-parameter router learns operation dispatch in one epoch
-3. The remaining challenge for full LLM integration is learning bit encoding from hidden states
-4. This validates the core thesis: discrete computational substrates can provide exact arithmetic
+The `train_passthrough_*.py` files demonstrate that routing works when given labels, but this is trivial—the real test is learning to parse from natural language.
 
 #### Proof of Concept Scope
 
-This proof of concept validated the core mechanism:
-
 - **8-bit operands** (0-255)
 - **Six operations**: ADD, SUB, MUL, GT, LT, EQ
 - **Pure ALU profile** (no memory access)
-- **Ground truth bits** (bit encoding from hidden states is the next step)
 
-With core validation complete, we proceed with the extension roadmap.
+**Current status**: Circuit validation complete. LLM hidden state extraction in development.
 
 ### Extension Roadmap
 
@@ -589,9 +590,9 @@ The following extensions are planned after proof-of-concept validation:
 | `llm_integration/baseline.py` | SmolLM2-360M arithmetic baseline evaluation (11.90% fitness) |
 | `llm_integration/fitness.py` | Shared fitness function for randomized arithmetic tests |
 | `llm_integration/circuits.py` | Frozen threshold circuit wrapper with STE gradients |
-| `llm_integration/model.py` | ThresholdALU model with trainable interface layers |
-| `llm_integration/train.py` | Full training script for encoder + router |
-| `llm_integration/train_router.py` | Router-only training (achieves 100% in 1 epoch) |
+| `llm_integration/model.py` | Interface layer definitions (BitEncoder, OpRouter, BitDecoder) |
+| `llm_integration/train_passthrough.py` | Scaffolding: trains with pre-formatted bit inputs |
+| `llm_integration/train_passthrough_router.py` | Scaffolding: router-only with ground truth bits |
 
 ### Build Tool Usage