🚀 OS Launch: Clean documentation and refined licensing

This OS launch commit includes:

✅ **Cleaned Documentation**
- Removed inflated claims and marketing language
- Added honest research status and limitations
- Created professional model card and validation reports
- Streamlined licensing to AGPLv3 + commercial contact

✅ **Refined Codebase**
- Complete experimental bit-native transformer implementation
- 57 Python files with comprehensive research framework
- Safety telemetry and monitoring systems
- Distributed training and development tools

✅ **Professional Standards**
- Empirical validation of all claims
- Clear experimental vs production distinctions
- Rigorous research methodology requirements
- Community contribution framework

Ready for serious research evaluation and academic investigation.

wikitext_schedule.py

@@ -0,0 +1,130 @@
+import numpy as np
+import torch
+import torch.nn.functional as F
+from torch.utils.data import Dataset
+from pathlib import Path
+from datasets import load_dataset
+
+from bit_transformer import (
+    BitTransformerLM,
+    configure_optimizer,
+    expand_model,
+    text_to_bits,
+)
+from bit_transformer.training import train_loop as basic_train
+
+
+def _build_memmap(lines, path: Path, max_len: int) -> None:
+    """Precompute bit tensors into a memory-mapped file."""
+    arr = np.memmap(path, mode="w+", shape=(len(lines), max_len), dtype="uint8")
+    for idx, text in enumerate(lines):
+        bits = text_to_bits(text)[:max_len]
+        if len(bits) < max_len:
+            bits.extend([0] * (max_len - len(bits)))
+        arr[idx] = np.array(bits, dtype="uint8")
+    arr.flush()
+
+
+class MemmapDataset(Dataset):
+    """Dataset backed by a memory-mapped array."""
+
+    def __init__(self, path: Path, length: int, max_len: int) -> None:
+        self.path = path
+        self.length = length
+        self.max_len = max_len
+        self._arr = np.memmap(path, mode="r", shape=(length, max_len), dtype="uint8")
+
+    def __len__(self) -> int:  # pragma: no cover - trivial
+        return self.length
+
+    def __getitem__(self, idx: int) -> torch.Tensor:
+        return torch.from_numpy(self._arr[idx].astype("int64"))
+
+
+def progressive_scale_schedule(steps=12, max_len=64, dataset_size=128):
+    """Run deterministic scale-up on WikiText data."""
+    ds = load_dataset("wikitext", "wikitext-2-raw-v1")
+    train_lines = [t for t in ds["train"]["text"] if t.strip()][:dataset_size]
+    valid_lines = [t for t in ds["validation"]["text"] if t.strip()][: dataset_size // 4]
+
+    train_path = Path("wikitext_train.memmap")
+    valid_path = Path("wikitext_valid.memmap")
+    _build_memmap(train_lines, train_path, max_len)
+    _build_memmap(valid_lines, valid_path, max_len)
+
+    train = MemmapDataset(train_path, len(train_lines), max_len)
+    valid = torch.from_numpy(
+        np.memmap(valid_path, mode="r", shape=(len(valid_lines), max_len), dtype="uint8")
+    ).long()
+
+    layers = 1
+    width = 32
+    params = dict(
+        d_model=width,
+        nhead=4,
+        num_layers=layers,
+        dim_feedforward=width * 2,
+        max_seq_len=max_len,
+        reversible=True,
+        chunk_size=max_len,
+        use_autocast=True,
+        use_act=True,
+        act_threshold=0.9,
+    )
+    model = BitTransformerLM(**params)
+    steps_per_epoch = max(1, (len(train) + 7) // 8)
+    optimizer, scheduler = configure_optimizer(model, lr=1e-3, total_steps=(steps + 1) * steps_per_epoch)
+
+    results = []
+    for step in range(steps + 1):
+        basic_train(
+            model,
+            train,
+            epochs=1,
+            compress_prob=0.5,
+            log=False,
+            forward_kwargs=None,
+            num_workers=2,
+        )
+
+        with torch.no_grad():
+            logits, _ = model(valid)
+            pred = logits[:, :-1, :].reshape(-1, 2)
+            target = valid[:, 1:].reshape(-1)
+            val_loss = F.cross_entropy(pred, target).item()
+        print(f"Step {step} validation loss: {val_loss:.4f}")
+        results.append((step, val_loss))
+
+        if step < steps:
+            if step % 2 == 0:
+                layers *= 2
+            else:
+                width *= 2
+            params = dict(
+                d_model=width,
+                nhead=4,
+                num_layers=layers,
+                dim_feedforward=width * 2,
+                max_seq_len=max_len,
+                reversible=True,
+                chunk_size=max_len,
+                use_autocast=True,
+                use_act=True,
+                act_threshold=0.9,
+            )
+            model = expand_model(model, params)
+            optimizer, scheduler = configure_optimizer(model, lr=1e-3, total_steps=(steps - step) * steps_per_epoch)
+            print(f"Scaled model to {layers} layers and width {width}")
+    return results
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Deterministic scale-up benchmark")
+    parser.add_argument("--steps", type=int, default=12, help="number of scale-up steps")
+    parser.add_argument("--max-len", type=int, default=64, help="sequence length")
+    parser.add_argument("--dataset-size", type=int, default=128, help="number of training lines")
+    args = parser.parse_args()
+
+    progressive_scale_schedule(steps=args.steps, max_len=args.max_len, dataset_size=args.dataset_size)