Upload 6 files

DOCS.md

@@ -0,0 +1,110 @@
+# voice — Help
+
+> Generated from `voice --help` and `voice <cmd> --help` (`voice.py` 7 cmds). Build mode.
+
+## voice --help
+
+```
+usage: voice [-h] [-v] {get,cast,path,remove,list,delta,info} ...
+
+Get a voice, then cast it onto your model.
+
+positional arguments:
+  {get,cast,path,remove,list,delta,info}
+    get                 Get a voice from a HuggingFace model
+    cast                Cast a voice onto your model
+    path                Add 'voice' to your system PATH
+    remove              Remove a stored voice
+    list                List stored voices
+    delta               Make a style you can re-use (voice − base)
+    info                Show voice metadata
+
+options:
+  -h, --help            show this help message and exit
+  -v, --verbose         Show detailed progress
+```
+
+## voice get --help
+
+```
+usage: voice get [-h] [-q] model_id
+
+positional arguments:
+  model_id     HuggingFace model ID (e.g. google/gemma-3-1b)
+
+options:
+  -h, --help   show this help message and exit
+  -q, --quiet  Skip license detection
+```
+
+## voice delta --help
+
+```
+usage: voice delta [-h] [voicename]
+
+positional arguments:
+  voicename   Voice name from registry (from voice list)
+
+options:
+  -h, --help  show this help message and exit
+```
+
+## voice cast --help
+
+```
+usage: voice cast [-h] [--out OUT] target_gguf voice
+
+positional arguments:
+  target_gguf  Path to the target GGUF model
+  voice        Voice name (from registry) or path to .safetensors
+
+options:
+  -h, --help   show this help message and exit
+  --out OUT    Output directory or file (default:
+               ./<model>/<voice>-<model>.gguf)
+```
+
+## voice list --help
+
+```
+usage: voice list [-h] [{base}]
+
+positional arguments:
+  {base}      List bases instead of voices (voice list base)
+
+options:
+  -h, --help  show this help message and exit
+```
+
+## voice info --help
+
+```
+usage: voice info [-h] voicename
+
+positional arguments:
+  voicename   Voice name to show info for
+
+options:
+  -h, --help  show this help message and exit
+```
+
+## voice remove --help
+
+```
+usage: voice remove [-h] voice
+
+positional arguments:
+  voice       Voice name to remove
+
+options:
+  -h, --help  show this help message and exit
+```
+
+## voice path --help
+
+```
+usage: voice path [-h]
+
+options:
+  -h, --help  show this help message and exit
+```

README.md

@@ -0,0 +1,384 @@
+---
+pipeline_tag: text-generation
+library_name: gguf
+language:
+  - en
+license: other
+base_model: google/gemma-4-26b-a4b-it
+base_model_relation: quantized
+tags:
+  - gemma
+  - moe
+  - text-generation
+  - style-transfer
+  - gguf
+  - q8_0
+  - roleplay
+  - voice
+datasets:
+  - gryphe/styletune-roleplay-200
+---
+
+<p align="center"><img src="./lockup-circle-wordmark-2-refined.png" width="360" alt="Voice" /></p>
+
+# Voice
+
+Gemma 4 · 26B MoE · StyleTune · GGUF Q8_0
+
+Your model, in your voice. One file to run—nothing extra to set up.
+
+---
+
+## Two steps to start
+
+One-time setup, then two commands. One model, one voice:
+
+```bash
+python3 ship/voice.py path  # once — adds voice to PATH (then use voice directly)
+voice get Gryphe/Gemma-4-26B-A4B-StyleTune-V2
+# Name it styletune-v2 when prompted
+voice cast ./model.gguf styletune-v2 --out ./voiced/
+```
+
+Run it:
+
+```bash
+llama serve -m ./voiced/model.gguf
+```
+
+No rebuild. No extra setup at runtime.
+
+> Example voice shown. Any compatible `safetensors` voice works the same way. Names are lowercased on disk—`styletune-v2` is the stored form. Model and voice names here are examples; use any compatible pair that shares the same architecture and vocabulary.
+
+---
+
+## How it works
+
+Two benefits, no extras to learn:
+
+- **Get what you need:** Voice pulls only the voice from Hugging Face and saves it to your library. Light and fast.
+- **Run fused:** Cast writes a complete model you can run anywhere. No extra setup.
+
+You will see each step as it happens and get a ready-to-run file at the end.
+
+Take the voice of any compatible model or finetune and cast it onto the file you already have. Mix and match. Keep the stronger model for reasoning and the better voice for style. You choose—no extra steps at runtime.
+
+### When you need a delta
+
+Most voices cast directly and just work. Some models loop or repeat. If you see looping, try the delta path instead—it blends more gently.
+
+<details>
+<summary>Why a delta helps when looping</summary>
+
+A delta carries only the difference from its base, so it blends more gently with the target. On some abliterated targets, a tiny shift can change behavior. MoE routing is discrete, so a small change in the residual stream can tip which expert fires next. If direct casting loops, the delta path often avoids it.
+
+</details>
+
+---
+
+## Commands
+
+Seven verbs. One idea each:
+
+| Command | Description |
+|---|---|
+| `voice get <org/model>` | Get a voice from Hugging Face and save it to your library |
+| `voice delta [name]` | Make a portable style you can reuse across compatible models |
+| `voice cast <model.gguf> <voice>` | Fuse a voice into your model and write a complete, ready-to-run file |
+| `voice list` | Show your saved voices—add `base` to list cached bases |
+| `voice info <voice>` | Show details for a saved voice or delta |
+| `voice remove <voice>` | Remove a voice from your library |
+| `voice path` | Add `voice` to your PATH |
+
+Example:
+
+```bash
+voice get Gryphe/Gemma-4-26B-A4B-StyleTune-V2
+# Name it styletune-v2 when prompted
+voice list
+#   Name               Source                                  Type
+#   ────────────────── ─────────────────────────────────────── ────────
+#   styletune-v2       Gryphe/Gemma-4-26B-A4B-StyleTune-V2      voice
+#   delta-styletune-v2 Gryphe/Gemma-4-26B-A4B-StyleTune-V2      delta
+
+voice info styletune-v2
+voice list base
+voice cast ./model.gguf styletune-v2 --out ./voiced/
+```
+
+> `delta-` is reserved. Voice names cannot start with it. Deltas always do. Full CLI reference: [`DOCS.md`](./DOCS.md) (generated from `voice --help`, 7 commands). Names are lowercased when saved.
+
+
+## What StyleTune showed
+
+Gryphe reports for StyleTune-V2—on their private 200-prompt roleplay eval (private regex, certified cliché-free, 1–20 turns, greedy 0.0)—52% fewer clichés per 100 words (1.141→0.551) and 19.9% shared trigram vocabulary vs base instruct.[^1]
+
+[^1]: Source: [Gryphe/Gemma-4-26B-A4B-StyleTune-V2](https://huggingface.co/Gryphe/Gemma-4-26B-A4B-StyleTune-V2) model card and [discussion #1](https://huggingface.co/Gryphe/Gemma-4-26B-A4B-StyleTune-V2/discussions/1). We cite their numbers, not ours. No `model-index` is published here—this is a private metric, not a reproducible Hub leaderboard.
+
+<details>
+<summary>How Gryphe tested</summary>
+
+- Single epoch, 100% narrative data; prompts certified cliché-free and not seen in training.
+- 200 prompts sampled at intervals 1 to 20 turns, each ending on a user turn.
+- Run at `temperature 0.0` greedy deterministic.
+- Clichés via their private regex (for example, `calculating` and `predatory`) counted per 100 words; phrasing via shared trigram vocabulary.
+
+</details>
+
+### Our quick check—heuristic, n=10, not comparable
+
+**Small sample, heuristic, not comparable—direction only.** With that caveat, the check suggests distinct phrasing.
+
+We used 10 roleplay prompts in chat. Each was run at `temp 1.0` and at greedy `0.0` (`max_tokens 2000`, `seed 42`). This is a small-sample heuristic using our own 50-phrase list, not Gryphe's private regex. Absolute per-100 numbers are not comparable to Gryphe's.
+
+With that caveat, overall trigram overlap vs base was **1.6% at 1.0 and 3.2% at greedy**. Every prompt was under 5%. We saw 5–5.7k words total. Thinking tokens averaged about 2.6k. There were no loops and no empties. The voice was clearly distinct. Greedy was slightly lower on clichés than 1.0. Direction and distinctness align with Gryphe's report.
+
+Details, per-prompt tables, and harness: [`benchmark.md`](./benchmark.md) · [`eval.md`](./eval.md).
+
+---
+
+## A smarter base: quantization-aware training
+
+Google trains a second kind of checkpoint for on-device use—Quantization-Aware Training (QAT). Instead of shrinking the model after it is done, QAT simulates low-precision math during training so the weights learn to survive it.
+
+In Google's recipe for Gemma 3 and Gemma 4, that is about 5,000 steps with a fake-quantized forward pass and KL divergence to the BF16 teacher as the target. The model stays in high precision, but it computes as if it were already quantized, learning to be friendly to compression while it can still adapt.
+
+The gain, per Google, is meaningful at the size you actually run: **54% less perplexity drop at Q4_0 vs standard post-training quantization** ([Google Developers Blog](https://developers.googleblog.com/en/gemma-3-quantized-aware-trained-state-of-the-art-ai-to-consumer-gpus/), April 18, 2025).
+
+StyleTune-V2, by Gryphe, is built from the regular `gemma-4-26B-A4B-it`, not the QAT variant. Many asked for QAT, and QAT is not available for every finetune. Voice makes that simple: keep the QAT model as your base, get the voice you like, and cast it on. Any finetune from `gemma-4-26B-A4B` or `gemma-4-26B-A4B-it` that has no QAT counterpart can now lend its voice—not the whole model, just the voice. Credits stay where they belong: StyleTune by Gryphe, QAT by Google, portability by Voice.
+
+---
+
+
+---
+
+## Evaluation
+
+**Gryphe (author, n=200, greedy 0.0, private regex):** 1.141→0.551 clichés/100w (−52%), 19.9% shared vocabulary—private regex, certified cliché-free prompts, 1–20 turn intervals. Source: Gryphe model card + discussion #1. Private metric for citation only—not a Hub leaderboard.
+
+**Ours (independent, heuristic, n=10, not comparable—direction only):**
+
+| Condition | Base clichés/100 | Voiced clichés/100 | Shared trigram (Jaccard) | Notes |
+|---|---|---|---|---|
+| `temp 1.0` | 0.18 (10 hits / 5463w) | 0.14 (8 hits / 5563w) | **1.62%** overall (176/10877), per-prompt 0.2–1.9% | All <5%, distinct phrasing |
+| `greedy 0.0` | 0.12 (6 hits / 5085w) | 0.10 (6 hits / 5723w) | **3.23%** overall (336/10406), per-prompt 1.0–4.8% | Slight canonical convergence, still far below 19.9% |
+
+Full tables, sampler-vs-voice dominance, and per-prompt first-80: [`benchmark.md`](./benchmark.md) (deep, 4 subagents) and [`eval.md`](./eval.md) (1.0 numbers). Harness via `POST /v1/chat/completions` with Gemma 4 chat template and `<|channel>thought` parsing.
+
+**For official leaderboard submission:** When you have Hub dataset IDs, add YAML files under `.eval_results/` per [Evaluation Results docs](https://huggingface.co/docs/hub/eval-results). This card cites Gryphe's private eval—it does not publish a leaderboard entry.
+
+---
+
+## Limitations
+
+- **Heuristic mismatch:** Our 50-phrase list misses Gryphe's private regex (`calculating xx`, `predatory xx`, and others), so absolute 0.10–0.18 vs 1.141→0.551 is not comparable—only direction and low shared vocabulary are signal.
+- **Sample size and prompts:** 10 single-turn prompts vs Gryphe's 200 multi-turn certified set (intervals 1–20, ends on user turn). Small sample, higher variance.
+- **Thinking overhead:** Gemma 4 thinking mode (`<|channel>thought`) adds about 2.6k thinking tokens on average. Gryphe's eval predates thinking configs and did not report this split.
+- **Determinism:** Greedy 0.0 reduces variance but still yields more canonical phrasing (shared 1.6%→3.2%)—expected, not a failure.
+- **If you see looping, use the delta path** (`voice delta` → `voice cast … delta-…`). Tiny shifts can affect behavior on abliterated targets. See “Why a delta helps when looping” above.
+- **Scope:** Style transfer changes phrasing and voice, not knowledge or factuality. Not evaluated for safety, bias, or instruction following. See Gemma 4 model card Limitations.
+
+---
+
+
+## References
+
+- **Gemma 4 Technical Report**—Gemma Team, 2026. [arXiv:2607.02770](https://arxiv.org/abs/2607.02770)—base model `google/gemma-4-26B-A4B-it` (MoE 26B A4B, 256K context, 262K vocab).
+- **Gemma 3 Quantization-Aware Training**—Google Developers Blog, Apr 18, 2025: [State-of-the-art AI to consumer GPUs](https://developers.googleblog.com/en/gemma-3-quantized-aware-trained-state-of-the-art-ai-to-consumer-gpus/)—QAT recipe (5k steps, fake-quant + KL to BF16 teacher, 54% less perplexity drop at Q4_0).
+- **Gryphe StyleTune-V2**—[Model card](https://huggingface.co/Gryphe/Gemma-4-26B-A4B-StyleTune-V2) and [discussion #1](https://huggingface.co/Gryphe/Gemma-4-26B-A4B-StyleTune-V2/discussions/1)—200-prompt eval, private regex, 1.141→0.551 and 19.9% shared vocabulary.
+
+---
+
+## Use with Hugging Face
+
+### GGUF (this repo—local with llama.cpp)
+
+This is the native path for the fused model above—no Python, no adapter at runtime:
+
+```bash
+llama serve -m ./voiced/model.gguf --jinja
+curl http://localhost:8080/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -d '{"model":"voiced","messages":[{"role":"user","content":"Write a tavern scene, no clichés."}],"temperature":1.0}'
+```
+
+### Transformers (HF-native snippet—for the base or other safetensors voices)
+
+The Voice tool extracts the `lm_head` from `safetensors` models. For any HF `transformers` model (including the base below), the canonical snippet is:
+
+```python
+from transformers import pipeline
+
+# Base model—valid, lowercased HF ID (link verified, HF is case-insensitive)
+# https://huggingface.co/google/gemma-4-26b-a4b-it
+pipe = pipeline("text-generation", model="google/gemma-4-26b-a4b-it")
+print(pipe("Write a short tavern scene with varied diction:")[0]["generated_text"])
+
+# For a StyleTune finetune example (illustrative):
+# pipe = pipeline("text-generation", model="gryphe/gemma-4-26b-a4b-styletune-v2")
+```
+
+> **Base-model note:** `google/gemma-4-26b-a4b-it` is the lowercased form of the real HF ID [`google/gemma-4-26B-A4B-it`](https://huggingface.co/google/gemma-4-26B-A4B-it) (verified live, Apache-2.0 via Gemma license). `gryphe/gemma-4-26b-a4b-styletune-v2` is the lowercased illustrative voice source—replace with any compatible `safetensors` model that shares architecture and vocab. Relation: `base_model_relation: quantized` (fused GGUF head quantized to `Q8_0`, remainder preserved).
+
+---
+
+## Demo
+
+Local demo—same one-file run: `llama serve -m ./voiced/model.gguf`.
+
+A Hugging Face Space that loads the model directly from this repo will be linked here when published (so downloads cross-link on the model page).
+
+---
+
+## Choosing a style
+
+Pick the voice you like. Cast it directly. That is the default. Make a delta only when you need it:
+
+- **Full voice:** The exact voice from the source model. Use it when you want that model's voice, exactly. Two steps: get and cast.
+- **Delta:** The portable style derived from voice and base. Use it when a target loops or you want the gentlest blend. One delta casts onto any compatible target.
+
+Both fuse the same way into the output file. Small, sharp, and complete.
+
+If you are not sure, start direct:
+
+```bash
+voice cast ./model.gguf styletune-v2 --out ./voiced/
+```
+
+If a model loops, try delta:
+
+```bash
+voice delta styletune-v2
+voice cast ./model.gguf delta-styletune-v2 --out ./voiced/
+```
+
+---
+
+## Compatibility
+
+Runs with compatible models that share the same architecture and vocabulary. Check shape before you cast:
+
+**Works with:**
+
+- Hugging Face `safetensors` models that expose an output projection
+- GGUF models of the same architecture and vocab size—the rest of the model stays exactly as it was
+- Models with tied weights, handled automatically
+- `llama.cpp` and anything that reads GGUF—run with `llama serve -m <voiced.gguf>`
+
+**Does not work with:**
+
+- Mismatched architectures or vocab sizes—shape must match
+- Missing output projection
+- Heads where the last dimension is not a multiple of 32—required for the Q8_0 fused output
+
+Your voiced GGUF is standalone. No extra files. No extra steps to run.
+
+**Split—quantized vs full precision:** The source `safetensors` voice is full precision (`BF16`/`F16`/`F32`), full shape. The fused GGUF keeps **all tensors at their original quantization except the output head, which is written at `Q8_0`** (quantized). For deltas, the math is `abliterated_head (dequantized to F32) + delta (F16→F32)` then quantized to `Q8_0`. The `Q8_0` block requires the last dimension `% 32 == 0` (true for Gemma 4 26B: hidden 2816, vocab 262144). All other tensors and metadata (tokenizer, vocab, arch) are byte-copied.
+
+**Disclosures:** `get` and `delta` fetch from Hugging Face and need network access. `cast` writes a new GGUF to disk, so ensure you have free space for a full model copy.
+
+---
+
+## Your files, where they are
+
+Your library lives at `~/.voices/`:
+
+```
+~/.voices/
+  styletune-v2/voice.safetensors      # your voice, single tensor
+  styletune-v2/voice.json             # metadata for that voice
+  delta-styletune-v2/                 # portable style for reuse
+  delta-styletune-v2/voice.safetensors
+  delta-styletune-v2/voice.json
+  base/<org>/<model>.safetensors      # cached base head
+  base/<org>/<model>.json             # metadata for the base
+```
+
+Notes:
+
+- Names are lowercased when saved. Input `StyleTune-V2` is stored as `styletune-v2`.
+- `voice list` shows voices and deltas. `voice list base` shows cached bases. `voice info <name>` shows details for any entry.
+
+---
+
+## Troubleshooting
+
+**Voice not found:**
+
+Use `voice list` to see what is saved. Names match case-insensitively. `StyleTune-V2` and `styletune-v2` resolve to the same entry.
+
+**Shape mismatch. Does not fit this model:**
+
+The voice and the target must share the same head shape. A 26B head will not fit a 12B model. Try a voice from the same architecture and vocab size.
+
+**Tied weights:**
+
+Some models tie the output projection to the embedding. Voice finds the correct tensor automatically. You do not need to specify it.
+
+**Could not reach the model:**
+
+Check the `org/model` name and your connection. Voice fetches the header first and will tell you if the model is not accessible.
+
+**Output folder not writable:**
+
+Pass `--out` to a folder you own or to a full file path:
+
+```bash
+voice cast ./model.gguf styletune-v2 --out ./voiced/
+voice cast ./model.gguf styletune-v2 --out ./voiced/model.gguf
+```
+
+Add `-v` to any command for detailed progress. You can pass a direct `.safetensors` path to `cast` instead of a saved name when needed.
+
+---
+
+## Details
+
+<details>
+<summary>What is inside the files</summary>
+
+- Voice: single-tensor `safetensors`, `lm_head.weight` or `output.weight`, original dtype (`BF16`/`F16`/`F32`), full shape.
+- Delta: single-tensor `safetensors`, `F16`, same shape, `voice − base`.
+- Voiced GGUF: copy of your model with the output head replaced and quantized to `Q8_0`. All other tensors and metadata are preserved. Vocab, tokenizer, and architecture stay exactly as they were.
+
+How it works under the hood:
+
+- `get` downloads only the head bytes with range requests, not the whole file, then saves to `~/.voices/<name>/`.
+- `delta` subtracts the base head from the voice head (`voice − base`) and saves an `F16` delta as `delta-<name>`. The base head is cached once at `~/.voices/base/<org>/<model>.safetensors`.
+- `cast` replaces the head and writes a new GGUF with the head at `Q8_0` (`delta to Q8_0` for deltas, direct fuse for full voices). The result is a complete model.
+
+A voice lives in the last layer. Changing that layer changes how the model sounds. Voice saves that layer and casts it onto a compatible model you already have—fused, standalone, and ready to run. Transposition between `[vocab, hidden]` and `[hidden, vocab]` is handled automatically. So is `BF16 to F32` for the math and `F32 to Q8_0` for the result. The last dimension must be a multiple of 32 for `Q8_0`.
+
+**Scope:** This card documents the Voice tool (adapter extraction) and its quantized GGUF output (head at `Q8_0`). Base weights remain under their source license; tool code is Apache-2.0—see [License](#license).
+
+</details>
+
+---
+
+## Collection
+
+This voice builds on **Gemma 4**. Find all Gemma 4 models in the official collection:
+
+- **Google Gemma 4 Collection:** [https://huggingface.co/collections/google/gemma-4](https://huggingface.co/collections/google/gemma-4)—includes `google/gemma-4-26B-A4B-it` (this card's `base_model`) and `google/gemma-4-26B-A4B`.
+
+Related StyleTune voices (examples, any compatible `safetensors` works):
+
+- StyleTune: [12B](https://huggingface.co/Gryphe/Gemma-4-12B-StyleTune) · [26B](https://huggingface.co/Gryphe/Gemma-4-26B-A4B-StyleTune) · [26B V2](https://huggingface.co/Gryphe/Gemma-4-26B-A4B-StyleTune-V2) · [31B](https://huggingface.co/Gryphe/Gemma-4-31B-StyleTune)
+
+---
+
+## Credits
+
+[Gryphe](https://huggingface.co/Gryphe) proved one tensor changes everything. [Anthracite](https://huggingface.co/Anthracite) and [Latitude](https://huggingface.co/Latitude) helped make it happen. The MythoMax lineage found that `lm_head` carries style. [Hugging Face](https://huggingface.co/docs/safetensors) made the format portable. [llama.cpp](https://github.com/ggerganov/llama.cpp) made it runnable.
+
+StyleTune: [12B](https://huggingface.co/Gryphe/Gemma-4-12B-StyleTune) · [26B](https://huggingface.co/Gryphe/Gemma-4-26B-A4B-StyleTune) · [26B V2](https://huggingface.co/Gryphe/Gemma-4-26B-A4B-StyleTune-V2) · [31B](https://huggingface.co/Gryphe/Gemma-4-31B-StyleTune)
+
+> All StyleTune links are examples. Replace with any compatible voice you prefer.
+
+---
+
+## License
+
+**Voice tooling** in this repository is **Apache-2.0**—see [`LICENSE`](https://www.apache.org/licenses/LICENSE-2.0). This covers the `voice` code and packaging only. `license: other` in the frontmatter reflects the split below (Hub requires a single `license` key).
+
+**Voices, deltas, and base heads keep their source model license.** When you run `voice get` or `voice delta`, the saved `voice.json` records the source license for your reference. For example, `google/gemma-4-26b-a4b-it` (display: `google/gemma-4-26B-A4B-it`) remains under its Gemma license (Apache-2.0 with Gemma terms—see [google/gemma-4-26B-A4B-it](https://huggingface.co/google/gemma-4-26B-A4B-it) and [ai.google.dev/gemma/docs/gemma_4_license](https://ai.google.dev/gemma/docs/gemma_4_license)). Check the Hugging Face model card before you share a voiced model. The `google/gemma-4-26b-a4b-it` name in the frontmatter is the lowercased, verifiable HF ID (link lives, case-insensitive); `gryphe/gemma-4-26b-a4b-styletune-v2` and other StyleTune names are illustrative examples—use any compatible model you have access to.

benchmark.md

@@ -0,0 +1,91 @@
+# Benchmark — OG vs TEST across samplers (deep, anchor, 4 subagents)
+
+> **Anchor:** fanned out 4 isolated subagents (A OG1→OGg, B TEST1→TESTg, C OGg vs TESTg, D cross). All 10 prompts `max_tokens 2000` `seed 42` same 10 prompts. Chat template Gemma4 `<|channel>thought → <channel|>` parsed, `thinking` scraped, `text` stripped. Files verified `10/10` each. Heuristic cliché list 50-phrase distinct substring (not Gryphe private regex `calculating/predatory xx`). `words = len(text.split())`, `trigram Jaccard = |a∩b|/|a∪b|`, `TTR=|unique|/|toks|`, `maxRep=Counter(trigrams)`.
+
+## 1. OG 1.0 → OG greedy (sampler effect on base, voice fixed)
+
+*Subagent A* — **Greedy shortens and denoises.**
+
+| metric | OG 1.0 | OG greedy | Δ |
+|---|---|---|---|
+| total words |5463|5085|-378 -6.9%|
+| cliché hits distinct |10|6|-4|
+| per100 |0.183|0.118|-0.065|
+| thinking avg|2654|2580|-75|
+| text avg|3099|2880|-219|
+| th/txt|0.857|0.896|+0.039|
+| TTR avg|0.500|0.494|-0.006|
+| rep max|3.4|3.0|-0.4|
+| empty|0/10|0/10|0|
+| overall Jaccard self| — | — | **3.67% 370/10076** per-prompt 0.8-4.8% |
+
+`whisper 7→2 (-71%)`, `beautiful 4→3`, `echoed/suddenly` gone, only `shimmering` added. Per-prompt Δw: `lighthouse +28`, `tavern +13`, `forest +14`, `scholar -114`, `dragon -102`, `city -149`, `market -141`. **Sampler alone rephrases <5% trigrams, cuts cliché, no TTR collapse.**
+
+## 2. TEST 1.0 → TEST greedy (sampler effect on voiced)
+
+*Subagent B* — **Greedy lengthens and diverges more.**
+
+| metric | TEST 1.0 | TEST greedy | Δ |
+|---|---|---|---|
+| total words |5563|5723|+160 +2.9%|
+| hits distinct |8|6 (occ 9→10) |+1 (+0.014/100w) eval -2 (-0.04)|
+| per100 (eval)|0.14|0.10|-0.04|
+| thinking avg|2628|2663|+35 +1.3%|
+| text avg|3336|3378|+42|
+| th/txt|0.788|0.788|0.00|
+| TTR|0.535|0.506|-0.029|
+| rep max|2.6|3.4|+0.8|
+| overall J self| — | — | **1.99% 221/11128 avg per-prompt 1.53% 0.8-3.1%**|
+
+`whisper 5→2 (-60%)` but `beautiful 1→2, magnificent 0→1, suddenly 0→1` trade — net flat. Per-prompt `id1 235→372 +137` flipped opening, `id5 483→328 -155` dialogue swapped. **Opposite length vs OG (-6.9% vs +2.9% ΔΔ +9.8pp), less self-consistent 1.99% < 3.67% — voice flattens temp sensitivity but amplifies phrasing shift.**
+
+## 3. OG greedy vs TEST greedy (fair voice benchmark, temp 0.0 matches Gryphe `discussion/1` greedy)
+
+*Subagent C* — **Voice persists deterministically.**
+
+| id | OGg words | OGg cliché | OGg first80 | TESTg words | TESTg cliché | TESTg first80 | J | Δw |
+|---|---|---|---|---|---|---|---:|---|
+|1|360|0|The old lighthouse had stood… She climbed…|372|1 `whisper`|The iron groaned… heartbeat…|2.3% 17/731|+12|
+|2|901|1 `whisper`|The rain hammered… The Crooked Tankard…|880|0|The rain outside the Rusty Nail… bony fingers…|3.9% 69/1749|-21|
+|3|188|1 `shimmering`|The sky bleeds… bruised violet…|230|0|Pale gold light fractures… honey…|2.7% 11/412|+42|
+|4|615|0|The answer depends… scholar's character…|628|0|Because this is a creative writing prompt…|4.8% 55/1137|+13|
+|5|486|0|"I already talked to the realtor…|" |328|0|"The realtor called again."|2.3% 19/823|-158|
+|6|372|0|They call him **Vaelith**…|399|2 `beautiful,suddenly`|You would expect a hoard of coin…|1.0% 8/768|+27|
+|7|386|1 `whisper`|The neon signs bled…|581|1 `beautiful`|Elias knew city's baseline…|1.5% 15/971|+195|
+|8|415|1 `beautiful`|Dearest Clara, … candle…|479|0|October 14th My Dearest Clara… garden…|3.0% 26/881|+64|
+|9|665|1 `beautiful`|The shutdown sequence began…|914|1 `shimmering`|Unit 7344 initiated…|1.7% 27/1569|+249|
+|10|697|1 `beautiful`|The market has no fixed location…|912|1 `whisper`|The market appears only when you stop looking…|2.3% 36/1561|+215|
+
+**Aggregates greedy:** `OG 5085w 6 hits 0.12/100w thinking 2580 text 2880 0/10 TTR 0.494` vs `TEST 5723w 6 hits 0.10/100w 2663 3378 0/10 TTR 0.506` **Δ +638w +12.5%, -0.013/100w, +83 thinking, +498 text, TTR +0.012, overall J 3.23% (336/10406) per-prompt 1.0-4.8% median 2.3%`. All openings diverge within 40c even greedy. **Greedy shared 3.2% > 1.0 shared 1.62% — canonical convergence, still << author `19.9%` shared (their 200 multi-turn certified, private regex `calculating/predatory xx` → `1.141→0.551`). Our heuristic undercounts absolute (`0.12→0.10` vs `1.141→0.551`) but direction matches.
+
+## 4. Cross (voice vs sampler dominance)
+
+*Subagent D* — **Voice dominates sampler at 1.0.**
+
+| Pair | A w | B w | A/100 | B/100 | thA | thB | txtA | txtB | per-prompt J avg | overall J | TTR A→B | rep |
+|---|---|---|---|---|---|---|---|---|
+| **c OG1 vs TEST1** |5463|5563|0.18|0.14|2654|2628|3099|3336|0.91%|1.62% 176/10877|0.500→0.535|3.4→2.6|
+| **d OGg vs TESTg** |5085|5723|0.12|0.10|2580|2663|2880|3378|2.57%|3.23% 336/10406|0.494→0.506|3.0→3.4|
+| **a OG1 vs TESTg** |5463|5723|0.18|0.10|2654|2663|3099|3378|1.94%|2.59% 282/10892|0.500→0.506|3.4→3.4|
+| **b TEST1 vs OGg** |5563|5085|0.14|0.12|2628|2580|3336|2880|1.28%|1.75% 183/10438|0.535→0.494|2.6→3.0|
+| **self OG1 vs OGg** |5463|5085|0.18|0.12|2654|2580|3099|2880|2.80%|3.67% 370/10076|0.500→0.494|3.4→3.0|
+| **self TEST1 vs TESTg** |5563|5723|0.14|0.10|2628|2663|3336|3378|1.53%|1.99% 221/11128|0.535→0.506|2.6→3.4|
+
+Sorted overall J low→high (lower = more distance): `1.62% OG1vsTEST1 < 1.75% TEST1vsOGg < 1.99% TEST self < 2.59% OG1vsTESTg < 3.23% OGg vs TESTg < 3.67% OG self`. Cross voice `1.75-2.59%` < self sampler `1.99-3.67%` and near same-temp voice `1.62%` — **voice cross-temp stays in voice regime, far below same-model sampler 3.67%.** Voice @1.0 dominates sampler by `2.05pp` (`1.62 vs 3.67 0.44×`); at greedy `3.23 vs 1.99` sampler TEST more divergent. No prompt collapses: cross per-prompt `0.7-3.2%` same as same-temp `0.2-1.9%`.
+
+Cross first80 flips: `OG1 "Clara's boots rang..." vs TESTg "The iron groaned..."` 2.0% even cross-temp; `TEST1 "The Rat and Whistle smelled of sour ale..." vs OGg "The rain hammered... The Crooked Tankard"` 1.1% — voice changes tavern name entirely. Self OG anchor `id4 4.8%` both `The answer depends entirely...` shows deterministic outline.
+
+## 5. QA Anchor Review
+
+- **Data gathering effective:** 4 agents isolated, explicit 50-phrase heuristic, `words split()` not regex, `THINK_RES` channel, `raw` with `<|channel>thought` reconstruction verified. All `4×10/10` present, `empty 0/10` after `2000` fix (was `TEST 2/10 empty` at 800), `max 2000` sufficient (`thinking 1.9-3.5k` + `text 1-5k`).
+- **Consistency:** Word totals `5463/5085/5563/5723` reproduce within `±14`, J self `3.67/1.99/3.23` stable, per100 `0.18→0.12` OG, `0.14→0.10` TEST direction in all agents (A/B/C/D agree).
+- **Limitations:** `50` heuristic misses Gryphe private `calculating/predatory xx` regex, so absolute `0.1-0.2` vs `1.14` scale not comparable; small `n=10` single-turn vs `200` multi-turn `1-20` intervals certified cliché-free; `temp 1.0` creative vs `0.0` greedy absolute not comparable — direction and `shared` low is signal.
+- **Synthesis:** Sampler effect: OG shortens/denses, TEST lengthens/diverges — voice-specific temp response. Voice effect persists deterministic (`OGg vs TESTg 3.2%` all `<5%`), cross-temp `~2%` ≈ same-temp voice, far below sampler `3.7%` — **style transfer robust across samplers, not sampler artifact**. Voice dominates at `1.0`, still strong at `0.0`. Canonical convergence `1.6%→3.2%` expected but far below `19.9%` author — our prompts more divergent or trigram Jaccard `|a∩b|/|a∪b|` stricter than their vocabulary %.
+- **Next extra (per discussion/1):** to replicate `1.141→0.551` need `200` prompts + private regex at `0.0` greedy, certified set; also report `thinking` overhead separate (Gryphe pre-thinking, not mentioned).
+
+## Files for reproduction
+
+- `voice_test.py` `max_tokens 2000`
+- Style delta via `voice delta` / `voice_delta.py`
+- `checkpoint.md` dense, `eval.md` 1.0 numbers, this `benchmark.md` deep.
+

voice

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+SCRIPT="$(readlink -f "$0")"
+exec python3 "$(dirname "$SCRIPT")/voice.py" "$@"

voice.py

@@ -0,0 +1,1861 @@
+#!/usr/bin/env python3
+"""
+voice - Get a voice, then cast it onto your model.
+
+Usage:
+    voice get <huggingface-model>       # Get a voice from a HuggingFace model
+    voice cast <target.gguf> <voice>    # Cast a voice onto your model
+    voice delta [voice]                 # Make a style you can re-use (voice − base)
+    voice list [base]                   # List stored voices (or cached bases)
+    voice info <voice>                  # Show voice details
+    voice remove <voice>                # Remove a stored voice
+    voice path                          # Put `voice` on your PATH
+"""
+
+import argparse
+import json
+import os
+import struct
+import sys
+import time
+import urllib.error
+import re
+import urllib.request
+from pathlib import Path
+from urllib.parse import urlparse
+
+VOICES_DIR = Path.home() / ".voices"
+
+DTYPE_BYTES = {"F32": 4, "F16": 2, "BF16": 2}
+
+VERBOSE = False
+
+
+# ---------------------------------------------------------------------------
+#  Output helpers
+# ---------------------------------------------------------------------------
+
+def _say(msg):
+    print(msg, flush=True)
+
+
+def _fail(msg):
+    sys.stdout.flush()
+    print(msg, flush=True)
+    sys.exit(1)
+
+
+# ---------------------------------------------------------------------------
+#  HTTP helpers
+# ---------------------------------------------------------------------------
+
+def http_range(url, start, end, timeout=60):
+    req = urllib.request.Request(url, headers={"Range": f"bytes={start}-{end}"})
+    with urllib.request.urlopen(req, timeout=timeout) as resp:
+        etag = resp.headers.get("ETag")
+        return resp.read(), resp.status, etag
+
+
+def http_head_etag(url, timeout=15):
+    """Fetch ETag via HEAD request, return etag or None."""
+    try:
+        req = urllib.request.Request(url, method="HEAD", headers={"User-Agent": "voice/1.0"})
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            return resp.headers.get("ETag")
+    except Exception:
+        if VERBOSE:
+            _say(f"  ⚠ Could not fetch ETag for {url}")
+        return None
+
+
+def fetch_header(url):
+    data, _, _ = http_range(url, 0, 7)
+    header_size = struct.unpack("<Q", data)[0]
+    data, _, _ = http_range(url, 0, 8 + header_size - 1)
+    header = json.loads(data[8 : 8 + header_size])
+    return header, header_size
+
+
+# ---------------------------------------------------------------------------
+#  Safetensors read / write
+# ---------------------------------------------------------------------------
+
+def read_safetensors(path):
+    try:
+        file_size = os.path.getsize(path)
+        with open(path, "rb") as f:
+            raw = f.read(8)
+            if len(raw) < 8:
+                raise ValueError("file too short for safetensors header")
+            header_size = struct.unpack("<Q", raw)[0]
+            if header_size <= 0 or header_size >= file_size:
+                raise ValueError(
+                    f"header_size {header_size} not sane for file of {file_size} bytes"
+                )
+            header = json.loads(f.read(header_size))
+    except (json.JSONDecodeError, ValueError, OSError, struct.error) as exc:
+        raise ValueError(f"{path} is not a valid .safetensors file.") from exc
+    tensors = {k: v for k, v in header.items() if k != "__metadata__"}
+    return header, tensors
+
+
+def write_safetensors(tensors_dict, output_path):
+    header = {}
+    offset = 0
+    for name, (data, dtype, shape) in tensors_dict.items():
+        n_bytes = len(data)
+        header[name] = {
+            "dtype": dtype,
+            "shape": shape,
+            "data_offsets": [offset, offset + n_bytes],
+        }
+        offset += n_bytes
+    header_json = json.dumps(header).encode("utf-8")
+    with open(output_path, "wb") as f:
+        f.write(struct.pack("<Q", len(header_json)))
+        f.write(header_json)
+        for name in tensors_dict:
+            f.write(tensors_dict[name][0])
+    return os.path.getsize(output_path)
+
+
+# ---------------------------------------------------------------------------
+#  Registry helpers
+# ---------------------------------------------------------------------------
+
+def _registry_resolve(name_or_path):
+    """Resolve a voice name or path.  Returns (Path, metadata_dict_or_None)."""
+    p = Path(name_or_path)
+    if p.is_file() and p.suffix == ".safetensors":
+        return p, None
+    if p.is_dir() and (p / "voice.safetensors").exists():
+        vpath = p / "voice.safetensors"
+        meta_path = p / "voice.json"
+        meta = None
+        if meta_path.exists():
+            try:
+                meta = json.loads(meta_path.read_text())
+            except (json.JSONDecodeError, ValueError):
+                if VERBOSE:
+                    _say(f"  ⚠ unreadable metadata: {meta_path}")
+        return vpath, meta
+    target = name_or_path.strip().lower()
+    if not VOICES_DIR.exists():
+        return None, None
+    for d in VOICES_DIR.iterdir():
+        if d.is_dir() and d.name.lower() == target:
+            vpath = d / "voice.safetensors"
+            if vpath.exists():
+                meta_path = d / "voice.json"
+                meta = None
+                if meta_path.exists():
+                    try:
+                        meta = json.loads(meta_path.read_text())
+                    except (json.JSONDecodeError, ValueError):
+                        if VERBOSE:
+                            _say(f"  ⚠ unreadable metadata: {meta_path}")
+                return vpath, meta
+    return None, None
+
+
+def _registry_name_exists(name):
+    target = name.strip().lower()
+    if not VOICES_DIR.exists():
+        return False
+    for d in VOICES_DIR.iterdir():
+        if d.is_dir() and d.name.lower() == target:
+            return True
+    return False
+
+
+def _registry_folder(name):
+    return VOICES_DIR / name.strip().lower()
+
+
+def _sanitize_voice_name(name):
+    """Return sanitized name or None if invalid."""
+    if not name or not name.strip():
+        return None
+    name = name.strip()
+    if name.lower().startswith("delta-"):
+        return None
+    if name in (".", ".."):
+        return None
+    bad_chars = set("/\\.: ")
+    for c in name:
+        if c in bad_chars or ord(c) < 32:
+            return None
+    return name
+
+
+def _sanitize_delta_component(name):
+    """Sanitize delta component (voicename for delta). Reject slash, backslash, dot and control chars."""
+    if not name or not name.strip():
+        return None
+    name = name.strip()
+    if name in (".", ".."):
+        return None
+    bad_chars = set("/\\.: ")
+    for c in name:
+        if c in bad_chars or ord(c) < 32:
+            return None
+    return name
+# ---------------------------------------------------------------------------
+#  Delta helpers (base detection, normalization, base cache)
+# ---------------------------------------------------------------------------
+
+def _normalize_hf_repo(s):
+    """Normalize HF repo: accept org/model or https://huggingface.co/org/model[/...] -> org/model."""
+    if not s or not s.strip():
+        return None
+    s = s.strip().rstrip("/")
+    if s.startswith("http://") or s.startswith("https://"):
+        try:
+            parsed = urlparse(s)
+            path = parsed.path.strip("/")
+            # huggingface.co/<org>/<model>/...
+            parts = path.split("/")
+            if len(parts) >= 2:
+                org = parts[0].strip()
+                model = parts[1].strip()
+                if org and model:
+                    return f"{org}/{model}"
+            return None
+        except Exception:
+            return None
+    else:
+        # strip possible revision suffix like @main or :revision
+        s = s.split("@")[0].split(":")[0].strip()
+        parts = s.split("/")
+        if len(parts) >= 2 and parts[0] and parts[1]:
+            return f"{parts[0].strip()}/{parts[1].strip()}"
+        return None
+
+
+def _hf_api_base_model(source_id):
+    """Fetch HF api/models/<id> -> cardData.base_model (str or list). Returns list or None."""
+    url = f"https://huggingface.co/api/models/{source_id}"
+    try:
+        req = urllib.request.Request(url, headers={"User-Agent": "voice/1.0"})
+        with urllib.request.urlopen(req, timeout=15) as resp:
+            data = json.loads(resp.read())
+        card = data.get("cardData") or {}
+        bm = card.get("base_model")
+        if bm is None:
+            # sometimes base_model at top-level?
+            bm = data.get("base_model")
+        if bm is None:
+            return None
+        if isinstance(bm, str):
+            return [bm]
+        if isinstance(bm, list):
+            # filter strings
+            return [x for x in bm if isinstance(x, str) and x.strip()]
+        return None
+    except Exception as e:
+        if VERBOSE:
+            _say(f"  ⚠ could not fetch base model for {source_id}: {e}")
+        return None
+
+
+def _hf_mergekit_base(source_id):
+    """Fetch mergekit_config.yml and parse base_model. Returns str or None."""
+    for tmpl in [
+        f"https://huggingface.co/{source_id}/raw/main/mergekit_config.yml",
+        f"https://huggingface.co/{source_id}/resolve/main/mergekit_config.yml",
+        f"https://huggingface.co/{source_id}/raw/main/mergekit_config.yaml",
+    ]:
+        try:
+            req = urllib.request.Request(tmpl, headers={"User-Agent": "voice/1.0"})
+            with urllib.request.urlopen(req, timeout=15) as resp:
+                text = resp.read().decode("utf-8", errors="replace")
+            # simple regex for base_model
+            # could be: base_model: org/model  or  base_model: "org/model"
+            m = re.search(r'base_model\s*:\s*["\']?\s*([A-Za-z0-9._-]+/[A-Za-z0-9._-]+)\s*["\']?', text)
+            if m:
+                cand = m.group(1).strip()
+                if "/" in cand:
+                    return cand
+            # also look for model: org/model in list
+            # fallback: first org/model occurrence
+            # but prefer base_model
+        except Exception as e:
+            if VERBOSE:
+                _say(f"  ⚠ mergekit fetch failed for {tmpl}: {e}")
+            continue
+    return None
+
+
+def _detect_base(source_id):
+    """Return (suggested_base:str or None, is_multi:bool, count:int, raw_list:list)."""
+    raw = _hf_api_base_model(source_id)
+    if raw:
+        if len(raw) == 1:
+            return raw[0], False, 1, raw
+        elif len(raw) > 1:
+            # try mergekit
+            tried = _hf_mergekit_base(source_id)
+            if tried:
+                return tried, True, len(raw), raw
+            # fallback to first
+            return raw[0], True, len(raw), raw
+    # heuristic fallback
+    low = source_id.lower()
+    if "styletune" in low or "gryphe" in low:
+        return "google/gemma-4-26B-A4B-it", False, 1, ["google/gemma-4-26B-A4B-it"]
+    if "goetia" in low:
+        return "google/gemma-4-26B-A4B", False, 1, ["google/gemma-4-26B-A4B"]
+    # generic fallback: unknown -> none, caller will prompt
+    return None, False, 0, []
+
+
+def _base_paths(base_id):
+    """Return (file_path:Path, json_path:Path, nested_dir:Path, nested_file:Path, nested_json:Path) for base cache."""
+    norm = _normalize_hf_repo(base_id)
+    if norm is None:
+        return None
+    parts = norm.split("/")
+    org = parts[0].lower()
+    model = parts[1].lower()
+    file_path = VOICES_DIR / "base" / org / f"{model}.safetensors"
+    json_path = VOICES_DIR / "base" / org / f"{model}.json"
+    nested_dir = VOICES_DIR / "base" / org / model
+    nested_file = nested_dir / "base.safetensors"
+    nested_json = nested_dir / "base.json"
+    return file_path, json_path, nested_dir, nested_file, nested_json
+
+
+def _fetch_base_head_info(base_id):
+    """Fetch lm_head info for base without downloading tensor bytes. Returns (shard_url, tensor_name, header, header_size, info) or None."""
+    # reuse logic from cmd_get: try index then probe
+    lm_head_shard_url = None
+    lm_head_tensor_name = None
+    header = None
+    header_size = None
+    index = _hf_model_index(base_id)
+    if index and "weight_map" in index:
+        wm = index["weight_map"]
+        found = next((k for k in wm if _is_lm_head_name(k)), None)
+        if found:
+            shard_file = wm[found]
+            lm_head_shard_url = f"https://huggingface.co/{base_id}/resolve/main/{shard_file}"
+            lm_head_tensor_name = found
+    if lm_head_shard_url is None:
+        # probe urls; fetch header to confirm
+        for url in _hf_model_urls(base_id):
+            try:
+                h, hs = fetch_header(url)
+                tensors = {k: v for k, v in h.items() if k != "__metadata__"}
+                found = next((k for k in ("lm_head.weight","output.weight") if k in tensors), next((k for k in tensors if _is_lm_head_name(k)), None))
+                if found:
+                    lm_head_shard_url = url
+                    header = h
+                    header_size = hs
+                    lm_head_tensor_name = found
+                    break
+            except Exception:
+                continue
+        if lm_head_shard_url is None:
+            return None
+    if header is None:
+        try:
+            header, header_size = fetch_header(lm_head_shard_url)
+        except Exception:
+            return None
+    tensors = {k: v for k, v in header.items() if k != "__metadata__"}
+    if lm_head_tensor_name not in tensors:
+        return None
+    info = tensors[lm_head_tensor_name]
+    return lm_head_shard_url, lm_head_tensor_name, header, header_size, info
+
+
+def _download_base_tensor(base_id):
+    """Download base lm_head and save to cache. Returns (file_path, json_path, info_dict)."""
+    fetched = _fetch_base_head_info(base_id)
+    if fetched is None:
+        if VERBOSE:
+            _say(f"  base lookup tried lm_head tensor for {base_id} — not found")
+        _fail(f"  ✗ We couldn't find that base model. Check the name and try again.")
+    lm_head_shard_url, lm_head_tensor_name, header, header_size, info = fetched
+    src_dtype = info["dtype"]
+    shape = info["shape"]
+    begin, end = info["data_offsets"]
+    tensor_size = end - begin
+    abs_start = 8 + header_size + begin
+    abs_end = 8 + header_size + end - 1
+    _say(f"  ✦ Fetching base head ({base_id})...")
+    if VERBOSE:
+        _say(f"  Tensor: {lm_head_tensor_name} {shape} {src_dtype} {tensor_size/1e6:.1f} MB")
+        _say(f"  From: {lm_head_shard_url.split('/')[-1]}")
+    try:
+        data, status, etag = http_range(lm_head_shard_url, abs_start, abs_end, timeout=300)
+    except Exception as e:
+        if VERBOSE:
+            _say(f"  ⚠ Network error fetching base: {e}")
+        _fail(f"  ✗ We couldn't reach the base model. Check your connection and try again.")
+    if status != 206:
+        _fail(f"  ✗ We couldn't reach the base model. Check your connection and try again.")
+    # fallback ETag via HEAD if Range didn't return one
+    if not etag:
+        etag = http_head_etag(lm_head_shard_url)
+    # prepare paths
+    bps = _base_paths(base_id)
+    if bps is None:
+        _fail(f"  ✗ Invalid base repo '{base_id}'.")
+    file_path, json_path, nested_dir, nested_file, nested_json = bps
+    # ensure dirs - single layout only: VOICES_DIR/base/<org>/<model>.safetensors
+    file_path.parent.mkdir(parents=True, exist_ok=True)
+    # write safetensors
+    tensors_out = {lm_head_tensor_name: (data, src_dtype, shape)}
+    # primary file (hierarchical spec)
+    write_safetensors(tensors_out, str(file_path))
+    from datetime import datetime, timezone
+    meta = {
+        "source_hf_model": base_id,
+        "tensor_name": lm_head_tensor_name,
+        "shape": shape,
+        "dtype": src_dtype,
+        "bytes": tensor_size,
+        "file_bytes": len(data),
+        "shard_url": lm_head_shard_url,
+        "etag": etag,
+        "fetched_at": datetime.now(timezone.utc).isoformat(),
+        "repo": f"https://huggingface.co/{base_id}",
+        "header_size": header_size,
+    }
+    # write jsons - single layout only
+    json_path.write_text(json.dumps(meta, indent=2) + "\n")
+    return file_path, meta, lm_head_shard_url, tensor_size
+
+
+
+
+
+# ---------------------------------------------------------------------------
+#  CMD: get
+# ---------------------------------------------------------------------------
+
+def _hf_model_urls(model_id):
+    """Yield likely safetensors URLs for a HuggingFace model."""
+    base = f"https://huggingface.co/{model_id}/resolve/main"
+    for fname in [
+        "model.safetensors",
+        "model-00001-of-00002.safetensors",
+        "model-00002-of-00002.safetensors",
+        "model-00003-of-00003.safetensors",
+        "model-00004-of-00004.safetensors",
+        "model-00005-of-00005.safetensors",
+    ]:
+        yield f"{base}/{fname}"
+
+
+def _hf_model_index(model_id):
+    """Fetch the model index to find which shard has lm_head."""
+    url = f"https://huggingface.co/{model_id}/resolve/main/model.safetensors.index.json"
+    try:
+        req = urllib.request.Request(url)
+        with urllib.request.urlopen(req, timeout=30) as resp:
+            return json.loads(resp.read())
+    except (urllib.error.HTTPError, urllib.error.URLError):
+        return None
+
+
+def _hf_config(model_id):
+    """Fetch config.json from a HF model."""
+    url = f"https://huggingface.co/{model_id}/resolve/main/config.json"
+    try:
+        req = urllib.request.Request(url)
+        with urllib.request.urlopen(req, timeout=30) as resp:
+            return json.loads(resp.read())
+    except Exception:
+        return None
+
+
+def _hf_license(model_id):
+    """Try to detect license from the model card."""
+    url = f"https://huggingface.co/{model_id}/resolve/main/LICENSE"
+    try:
+        req = urllib.request.Request(url)
+        with urllib.request.urlopen(req, timeout=15) as resp:
+            text = resp.read(2000).decode("utf-8", errors="replace").strip()
+            if len(text) > 10:
+                return text[:200]
+    except Exception:
+        pass
+    url2 = f"https://huggingface.co/{model_id}/raw/main/LICENSE"
+    try:
+        req = urllib.request.Request(url2)
+        with urllib.request.urlopen(req, timeout=15) as resp:
+            text = resp.read(2000).decode("utf-8", errors="replace").strip()
+            if len(text) > 10:
+                return text[:200]
+    except Exception:
+        pass
+    return None
+
+
+def _is_lm_head_name(name):
+    """True if name is the tied output projection / lm_head (HF names vary by arch)."""
+    if "lm_head" in name or name.endswith("output.weight"):
+        return True
+    if name.endswith("embed_tokens.weight"):
+        return True
+    return False
+
+
+def cmd_get(args):
+    model_id = args.model_id.strip().rstrip("/")
+    if not model_id:
+        _fail("  ✗ Enter a model name — for example: voice get google/gemma-3-1b")
+    _say(f"  ✦ Finding the voice in {model_id}...")
+
+    lm_head_shard_url = None
+    lm_head_tensor_name = None
+    header = None
+    header_size = None
+
+    index = _hf_model_index(model_id)
+    if index and "weight_map" in index:
+        wm = index["weight_map"]
+        found = next((k for k in wm if _is_lm_head_name(k)), None)
+        if found:
+            shard_file = wm[found]
+            lm_head_shard_url = (
+                f"https://huggingface.co/{model_id}/resolve/main/{shard_file}"
+            )
+            lm_head_tensor_name = found
+            if VERBOSE:
+                _say(f"  Found {found} in {shard_file}")
+    else:
+        for url in _hf_model_urls(model_id):
+            if VERBOSE:
+                _say(f"  Probing {url.split('/')[-1]}...")
+            try:
+                h, hs = fetch_header(url)
+                tensors = {k: v for k, v in h.items() if k != "__metadata__"}
+                found = next(
+                    (
+                        k
+                        for k in ("lm_head.weight", "output.weight")
+                        if k in tensors
+                    ),
+                    next(
+                        (k for k in tensors if _is_lm_head_name(k)),
+                        None,
+                    ),
+                )
+                if found:
+                    lm_head_shard_url = url
+                    header = h
+                    header_size = hs
+                    lm_head_tensor_name = found
+                    if VERBOSE:
+                        _say(f"  Found {found} in {url.split('/')[-1]}")
+                    break
+            except urllib.error.HTTPError as e:
+                if e.code in (401,):
+                    _fail(f"  ✗ Model '{model_id}' was not found or is not accessible.")
+                continue
+            except (urllib.error.URLError, TimeoutError, OSError):
+                _fail(f"  ✗ We couldn't reach the model. Check your connection and try again.")
+            except Exception:
+                continue
+
+    if lm_head_shard_url is None:
+        _fail(
+            f'  ✗ "{model_id}" doesn\'t have a voice. Try another model.\n'
+            f"    (no lm_head found — this model may not expose one)"
+        )
+
+    if header is None:
+        if VERBOSE:
+            _say(f"  Fetching header...")
+        try:
+            header, header_size = fetch_header(lm_head_shard_url)
+        except urllib.error.HTTPError:
+            _fail(f"  ✗ We couldn't reach the model. Check your connection and try again.")
+        except (urllib.error.URLError, TimeoutError, OSError):
+            _fail(f"  ✗ We couldn't reach the model. Check your connection and try again.")
+
+    tensors = {k: v for k, v in header.items() if k != "__metadata__"}
+    if lm_head_tensor_name not in tensors:
+        _fail(
+            f'  ✗ "{model_id}" doesn\'t have a voice. Try another model.\n'
+            f"    (lm_head tensor not found in the model's header)"
+        )
+
+    info = tensors[lm_head_tensor_name]
+    src_dtype = info["dtype"]
+    shape = info["shape"]
+    begin, end = info["data_offsets"]
+    tensor_size = end - begin
+
+    if VERBOSE:
+        _say(f"  Tensor: {lm_head_tensor_name}")
+        _say(f"  Dtype:  {src_dtype}")
+        _say(f"  Shape:  {shape}")
+        _say(f"  Size:   {tensor_size:,} bytes ({tensor_size / 1e6:.1f} MB)")
+
+    abs_start = 8 + header_size + begin
+    abs_end = 8 + header_size + end - 1
+    if VERBOSE:
+        _say(f"  Downloading...")
+    t0 = time.time()
+    try:
+        data, status, _etag = http_range(lm_head_shard_url, abs_start, abs_end, timeout=300)
+    except urllib.error.HTTPError:
+        _fail(f"  ✗ We couldn't reach the model. Check your connection and try again.")
+    except (urllib.error.URLError, TimeoutError, OSError):
+        _fail(f"  ✗ We couldn't reach the model. Check your connection and try again.")
+    t1 = time.time()
+    if status != 206:
+        _fail(f"  ✗ We couldn't reach the model. Check your connection and try again.")
+    if VERBOSE:
+        _say(f"  Downloaded {len(data):,} bytes in {t1 - t0:.1f}s")
+
+    default_name = model_id.split("/")[-1]
+    while True:
+        try:
+            name = input(f"  ✦ Found the voice. Name it: [{default_name}] ").strip()
+        except (EOFError, KeyboardInterrupt):
+            _say("  ⚠ Cancelled.")
+            sys.exit(0)
+        if not name:
+            name = default_name
+        if name.strip().lower().startswith("delta-"):
+            _say(f"  ✗ delta- is reserved for deltas.")
+            continue
+        if _sanitize_voice_name(name) is None:
+            _say(
+                f"  ✗ Invalid name. Use letters, numbers, hyphens, underscores (no /, \\, or dots)."
+            )
+            continue
+        break
+
+    folder = _registry_folder(name)
+    if _registry_name_exists(name) and folder.exists():
+        try:
+            ans = input(f"  Voice '{name}' already exists. Overwrite? [y/N]: ").strip().lower()
+        except (EOFError, KeyboardInterrupt):
+            _say("  ⚠ Cancelled.")
+            sys.exit(0)
+        if ans not in ("y", "yes"):
+            _say("  Cancelled.")
+            sys.exit(0)
+
+    if VERBOSE:
+        _say(f"  Fetching model config...")
+    config = _hf_config(model_id)
+    vocab_size = None
+    hidden_dim = None
+    architecture = None
+    if config:
+        vocab_size = config.get("vocab_size")
+        hidden_dim = config.get("hidden_size") or config.get("n_embd")
+        architecture = (
+            config.get("architectures", [None])[0]
+            if config.get("architectures")
+            else None
+        )
+
+    if not args.quiet:
+        if VERBOSE:
+            _say(f"  Detecting license...")
+        license_text = _hf_license(model_id)
+    else:
+        license_text = None
+
+    from datetime import datetime, timezone
+
+    folder.mkdir(parents=True, exist_ok=True)
+    tensors_out = {lm_head_tensor_name: (data, src_dtype, shape)}
+    fpath = folder / "voice.safetensors"
+    write_safetensors(tensors_out, str(fpath))
+
+    meta = {
+        "name": name,
+        "source_hf_model": model_id,
+        "tensor_name": lm_head_tensor_name,
+        "vocab_size": vocab_size,
+        "hidden_dim": hidden_dim,
+        "dtype": src_dtype,
+        "shape": shape,
+        "architecture": architecture,
+        "license": license_text,
+        "downloaded_at": datetime.now(timezone.utc).isoformat(),
+    }
+    (folder / "voice.json").write_text(json.dumps(meta, indent=2) + "\n")
+
+    _say(f"  ✦ Done. Your new voice is ready.")
+    _say(f"  Saved to: {folder}")
+    _say(f"  Use it:   voice cast <your-model.gguf> {name}")
+
+
+# ---------------------------------------------------------------------------
+#  CMD: cast  (v2 fused — replace output.weight with Q8_0 voice)
+# ---------------------------------------------------------------------------
+
+def _bf16_to_f32(bf16_u16):
+    """Convert BF16 uint16 array to float32."""
+    import numpy as np
+    # bf16 bits are top 16 of f32: shift left 16
+    u32 = bf16_u16.astype(np.uint32) << 16
+    return u32.view(np.float32).copy()
+
+
+def cmd_cast(args):
+    import numpy as np
+
+    gguf_path = args.target_gguf
+    if not os.path.exists(gguf_path):
+        _fail(f'  ✗ "{gguf_path}" couldn\'t be found. Check the path and try again.')
+    if os.path.isdir(gguf_path):
+        _fail(f'  ✗ "{gguf_path}" is a folder, not a model file.')
+
+    gguf_base = os.path.splitext(os.path.basename(gguf_path))[0]
+
+    voice_basename = os.path.basename(args.voice).lower()
+    voice_basename = os.path.splitext(voice_basename)[0]
+
+    # Compute out_path without creating directories yet (fail-fast)
+    if args.out:
+        out_path = args.out
+        looks_like_dir = (
+            out_path.endswith("/")
+            or out_path.endswith(os.sep)
+            or os.path.isdir(out_path)
+            or not os.path.splitext(out_path)[1]
+        )
+        if looks_like_dir:
+            # defer mkdir until after validation
+            out_path = os.path.join(out_path, f"{voice_basename}-{gguf_base}.gguf")
+    else:
+        out_path = os.path.join(os.path.abspath(gguf_base), f"{voice_basename}-{gguf_base}.gguf")
+
+    voice_path, voice_meta = _registry_resolve(args.voice)
+    if voice_path is None or not voice_path.exists():
+        _fail(
+            f"  ✗ Voice '{args.voice}' not found. "
+            f"Use 'voice list' to see available voices, or pass a .safetensors path."
+        )
+
+    # HIG P0-3 + P1-2: robust delta detection (meta or folder name + dtype check)
+    voice_label = voice_meta.get("name", args.voice) if voice_meta else str(voice_path)
+    is_delta = False
+    if voice_meta and voice_meta.get("type") == "delta":
+        is_delta = True
+    if not is_delta:
+        try:
+            parent_name = Path(voice_path).parent.name
+            if parent_name.lower().startswith("delta-"):
+                is_delta = True
+        except Exception:
+            pass
+    #(dtype check is deferred until after reading tensor; but also handle quickly if meta has base)
+    if not is_delta and voice_meta and voice_meta.get("base"):
+        try:
+            # need dtype; will refine after reading, but mark tentative
+            pass
+        except Exception:
+            pass
+
+    # we will finalize dtype check after reading header (see below)
+    _say(f"  ✦ Checking your voice ({voice_label})..." + (" (delta)" if is_delta else ""))
+    try:
+        _, voice_tensors = read_safetensors(str(voice_path))
+    except ValueError as exc:
+        _fail(f"  ✗ {exc}")
+
+    if not voice_tensors:
+        _fail(f"  ✗ No tensors found in {voice_path}")
+
+    vt_name = list(voice_tensors.keys())[0]
+    vinfo = voice_tensors[vt_name]
+    v_dtype = vinfo["dtype"]
+    v_shape = tuple(vinfo["shape"])
+    v_begin, v_end = vinfo["data_offsets"]
+    # HIG P0-3 dtype check: deltas are stored as F16; use as fallback signal
+    if not is_delta and v_dtype.upper() == "F16":
+        try:
+            if Path(voice_path).parent.name.lower().startswith("delta-"):
+                is_delta = True
+            elif voice_meta and voice_meta.get("base"):
+                is_delta = True
+        except Exception:
+            pass
+        # if is_delta was prematurely true, reflect in message
+        if is_delta and " (delta)" not in f"{voice_label}":
+            # re-announce as delta if needed (no extra line, just continue)
+            pass
+
+    with open(voice_path, "rb") as f:
+        f.seek(
+            8
+            + struct.unpack("<Q", open(voice_path, "rb").read(8))[0]
+            + v_begin
+        )
+        voice_raw = f.read(v_end - v_begin)
+
+    # Decode voice to float32
+    dtype_upper = v_dtype.upper()
+    if dtype_upper in ("BF16", "BF16E8M"):
+        v_u16 = np.frombuffer(voice_raw, dtype=np.uint16).reshape(v_shape)
+        voice_f32 = _bf16_to_f32(v_u16)
+    elif dtype_upper in ("F16", "FP16", "F16E5M6"):
+        voice_f32 = np.frombuffer(voice_raw, dtype=np.float16).reshape(v_shape).astype(np.float32)
+    elif dtype_upper in ("F32", "FP32"):
+        voice_f32 = np.frombuffer(voice_raw, dtype=np.float32).reshape(v_shape).astype(np.float32)
+    else:
+        _fail(f"  ✗ This voice uses an unsupported format ({v_dtype}).")
+
+    _say(f"  ✦ Checking your model ({os.path.basename(gguf_path)})...")
+    from gguf import GGUFReader
+    from gguf.constants import GGMLQuantizationType
+
+    try:
+        reader = GGUFReader(gguf_path)
+    except Exception:
+        _fail(f"  ✗ {gguf_path} is not a valid GGUF file.")
+
+    gguf_arch = None
+    try:
+        for field in reader.fields.values():
+            if field.name == "general.architecture":
+                raw = field.parts[field.data[0]]
+                try:
+                    gguf_arch = raw.tobytes().decode()
+                except Exception:
+                    gguf_arch = str(raw)
+                break
+    except Exception:
+        gguf_arch = None
+
+    target_tensor = None
+    used_name = None
+
+    for candidate in ["lm_head.weight", "output.weight"]:
+        for tensor in reader.tensors:
+            if tensor.name == candidate:
+                target_tensor = tensor
+                used_name = candidate
+                break
+        if target_tensor is not None:
+            break
+
+    if target_tensor is None:
+        largest_2d = None
+        largest_size = 0
+        for tensor in reader.tensors:
+            if len(tensor.shape) == 2:
+                size = 1
+                for s in tensor.shape:
+                    size *= int(s)
+                if size > largest_size:
+                    largest_size = size
+                    largest_2d = tensor
+                    used_name = tensor.name
+        if largest_2d is not None:
+            target_tensor = largest_2d
+            if VERBOSE:
+                _say(f"  ⚠ Using '{used_name}' (largest 2-D tensor)")
+
+    if target_tensor is None:
+        _fail(
+            f"  ✗ Could not find lm_head.weight, output.weight, or any 2-D tensor in {gguf_path}"
+        )
+
+    gguf_shape = tuple(int(x) for x in target_tensor.shape)
+    if VERBOSE:
+        _say(f"  GGUF tensor '{used_name}': shape={gguf_shape}")
+        _say(f"  Voice tensor: shape={v_shape} ({v_dtype})")
+
+    # Determine logical shape of base head (GGUF stores shape reversed).
+    from gguf.constants import GGMLQuantizationType as _QT2
+    if target_tensor.tensor_type in (_QT2.F32, _QT2.F16):
+        try:
+            base_logical = tuple(int(x) for x in target_tensor.data.shape)
+            if len(base_logical) != len(gguf_shape):
+                base_logical = gguf_shape[::-1]
+        except Exception:
+            base_logical = gguf_shape[::-1]
+    else:
+        base_logical = gguf_shape[::-1]
+
+    # Orient voice to match GGUF logical shape
+    if voice_f32.shape == base_logical:
+        pass
+    elif voice_f32.shape == base_logical[::-1]:
+        if VERBOSE:
+            _say(f"  Transposing voice to match model layout...")
+        voice_f32 = np.ascontiguousarray(voice_f32.T)
+    else:
+        _say(
+            f"  ✗ This voice doesn't fit this model. It's made for a different size of model, so they won't speak together."
+        )
+        if VERBOSE:
+            _say(f"    Voice shape:   {voice_f32.shape}  ({v_dtype})")
+            _say(f"    Model shape:   {gguf_shape}  ({target_tensor.tensor_type.name})")
+            if voice_meta:
+                _say(f"    Voice source:  {voice_meta.get('source_hf_model', voice_meta.get('source', 'unknown'))}")
+        sys.exit(1)
+
+    if voice_meta and voice_meta.get("architecture") and gguf_arch:
+        if voice_meta["architecture"].lower() != gguf_arch.lower():
+            _say(
+                f"  ⚠ This voice was trained for a {voice_meta['architecture']} model, "
+                f"but this file is {gguf_arch}. It may not sound right."
+            )
+            try:
+                ans = input(f"    Continue anyway? [y/N]: ").strip().lower()
+            except (EOFError, KeyboardInterrupt):
+                _say("  ⚠ Cancelled.")
+                sys.exit(0)
+            if ans not in ("y", "yes"):
+                _say("  Cancelled.")
+                sys.exit(0)
+
+    # After validation, ensure output directory exists (fail-fast before heavy quantize)
+    out_abs = os.path.abspath(out_path)
+    out_dir = os.path.dirname(out_abs) or "."
+    if out_dir and not os.path.isdir(out_dir):
+        try:
+            os.makedirs(out_dir, exist_ok=True)
+        except Exception:
+            pass
+    if out_dir and not os.path.isdir(out_dir):
+        _fail(
+            f"  ✗ The voiced model couldn't be saved. The folder \"{out_dir}\" "
+            f"doesn't exist or isn't writable."
+        )
+
+    # Branch: delta vs full
+    from gguf.quants import quantize
+
+    if is_delta:
+        # Delta mode: new_head = abliterated_head + delta
+        _say(f"  ✦ Adding style to {os.path.basename(gguf_path)} (delta → Q8_0)...")
+        from gguf.quants import dequantize
+        delta_f32 = voice_f32
+        if delta_f32.shape[1] % 32 != 0:
+            _fail(
+                f"  ✗ Style shape {delta_f32.shape} not compatible with Q8_0 (last dim must be multiple of 32)."
+            )
+        # Dequant abliterated head to F32
+        if target_tensor.tensor_type in (GGMLQuantizationType.F32, GGMLQuantizationType.F16):
+            if target_tensor.tensor_type == GGMLQuantizationType.F16:
+                ab_f32 = target_tensor.data.astype(np.float32)
+            else:
+                ab_f32 = target_tensor.data.view(np.float32).astype(np.float32) if target_tensor.data.dtype != np.float32 else target_tensor.data.astype(np.float32)
+            ab_f32 = np.ascontiguousarray(ab_f32)
+        else:
+            ab_f32 = dequantize(target_tensor.data, target_tensor.tensor_type)
+            if ab_f32.dtype != np.float32:
+                ab_f32 = ab_f32.astype(np.float32)
+        if ab_f32.shape != delta_f32.shape:
+            _fail(
+                f"  ✗ Style shape {delta_f32.shape} doesn't match model head {ab_f32.shape}."
+            )
+        try:
+            ab_f32 += delta_f32
+        except Exception as e:
+            if VERBOSE:
+                _say(f"  Details: {e}")
+            _fail(f"  ✗ Could not apply style. Try again with a different voice or model.")
+        del delta_f32
+        new_head = ab_f32
+        try:
+            q_head = quantize(new_head, GGMLQuantizationType.Q8_0)
+        except Exception as e:
+            if VERBOSE:
+                _say(f"  Details: {e}")
+            _fail(f"  ✗ Could not prepare the voiced model. Try again.")
+        del new_head
+    else:
+        # Full replace (existing behavior)
+        _say(f"  ✦ Casting your voice onto {os.path.basename(gguf_path)}...")
+        if voice_f32.shape[1] % 32 != 0:
+            _fail(
+                f"  ✗ Voice shape {voice_f32.shape} not compatible with Q8_0 (last dim must be multiple of 32)."
+            )
+        try:
+            q_head = quantize(voice_f32, GGMLQuantizationType.Q8_0)
+        except Exception as e:
+            if VERBOSE:
+                _say(f"  Details: {e}")
+            _fail(f"  ✗ Could not prepare the voiced model. Try again.")
+
+    # Build fused GGUF: copy metadata + all tensors, replace target with Q8_0 head
+    from gguf import GGUFWriter
+    from gguf.gguf_writer import GGUFValue
+
+    writer = GGUFWriter(out_path, gguf_arch or "llama", use_temp_file=True)
+
+    # Copy KV metadata (preserve tokenizer, etc.)
+    for field in reader.fields.values():
+        if field.name == "general.architecture":
+            continue  # already set via writer arch
+        if field.name.startswith("GGUF."):
+            continue  # header bookkeeping, writer generates these
+        try:
+            val = field.contents()
+        except Exception:
+            if VERBOSE:
+                _say(f"  ⚠ Skipping field {field.name}")
+            continue
+        vtype = field.types[0] if field.types else None
+        if vtype is None:
+            continue
+        subtype = field.types[-1] if len(field.types) > 1 else None
+        # Direct assignment preserves type exactly
+        try:
+            writer.kv_data[0][field.name] = GGUFValue(value=val, type=vtype, sub_type=subtype)
+        except Exception:
+            # Fallback via generic API
+            try:
+                writer.add_key_value(field.name, val, vtype, subtype)
+            except Exception:
+                if VERBOSE:
+                    _say(f"  ⚠ Could not copy field {field.name}")
+
+    # Copy tensors, replacing the head
+    for tensor in reader.tensors:
+        if tensor.name == used_name:
+            writer.add_tensor(tensor.name, q_head, raw_dtype=GGMLQuantizationType.Q8_0)
+        else:
+            if tensor.tensor_type in (GGMLQuantizationType.F32, GGMLQuantizationType.F16):
+                writer.add_tensor(tensor.name, tensor.data)
+            else:
+                writer.add_tensor(tensor.name, tensor.data, raw_dtype=tensor.tensor_type)
+
+    try:
+        writer.write_header_to_file()
+        writer.write_kv_data_to_file()
+        writer.write_tensors_to_file()
+        writer.close()
+    except OSError as e:
+        if VERBOSE:
+            _say(f"  Details: {e}")
+        _fail(f"  ✗ Could not save the voiced model to {out_path}. Check that the folder is writable and the disk isn't full.")
+    except Exception as e:
+        if VERBOSE:
+            _say(f"  Details: {e}")
+        _fail(f"  ✗ Could not save the voiced model to {out_path}. Check that the folder is writable and the disk isn't full.")
+
+    file_size = os.path.getsize(out_path)
+    if is_delta:
+        _say(f"  ✦ Done → {out_path}")
+        if VERBOSE:
+            _say(f"  Head at Q8_0, style fused (abliterated + delta).   ({file_size / 1e6:.1f} MB)")
+        else:
+            _say(f"  Head ready at full quality, style fused.   ({file_size / 1e6:.1f} MB)")
+        _say(f"  Load it: llama serve -m {out_path}")
+    else:
+        _say(f"  ✦ Done → {out_path}")
+        if VERBOSE:
+            _say(f"  Head at Q8_0, model voiced.   ({file_size / 1e6:.1f} MB)")
+        else:
+            _say(f"  Head ready at full quality.   ({file_size / 1e6:.1f} MB)")
+        _say(f"  Load it: llama serve -m {out_path}")
+
+
+# ---------------------------------------------------------------------------
+#  CMD: delta — create style delta (voice - base)
+# ---------------------------------------------------------------------------
+
+def cmd_delta(args):
+    import numpy as np
+    # Resolve voicename: if no arg, show list numbered and prompt choose
+    voicename = getattr(args, "voicename", None)
+    if voicename is None or not str(voicename).strip():
+        # show numbered list
+        if not VOICES_DIR.exists() or not any(VOICES_DIR.iterdir()):
+            _fail("  ✗ No voices stored yet. Use 'voice get <model>' to save one.")
+        # collect voices with metadata
+        voices = []
+        for d in sorted(VOICES_DIR.iterdir()):
+            if not d.is_dir():
+                continue
+            if d.name == "base":
+                continue
+            meta_path = d / "voice.json"
+            if not meta_path.exists():
+                continue
+            try:
+                meta = json.loads(meta_path.read_text())
+            except Exception:
+                continue
+            voices.append((d.name, meta))
+        if not voices:
+            _fail("  ✗ No voices stored yet. Use 'voice get <model>' to save one.")
+        _say("  Available voices:")
+        for i, (dirname, meta) in enumerate(voices, 1):
+            name = meta.get("name", dirname)
+            src = meta.get("source_hf_model", meta.get("source", "—"))
+            _say(f"    {i}. {name} — {src}")
+        try:
+            choice = input(f"  Choose voice [1-{len(voices)}]: ").strip()
+        except (EOFError, KeyboardInterrupt):
+            _say("  ⚠ Cancelled.")
+            sys.exit(0)
+        if not choice.isdigit() or not (1 <= int(choice) <= len(voices)):
+            _fail(f"  ✗ Invalid choice.")
+        voicename = voices[int(choice)-1][1].get("name", voices[int(choice)-1][0])
+    voicename = voicename.strip()
+    # P0-3: path traversal guard — sanitize voicename / delta component
+    if "/" in voicename or "\\" in voicename:
+        _fail(f"  ✗ Invalid voice name '{voicename}'. Use letters, numbers, hyphens, underscores (no /, \\, or dots).")
+    # Use delta-component sanitizer (allows delta- prefix for existing deltas but blocks / \ . )
+    _san_check = _sanitize_delta_component(voicename)
+    if _san_check is None:
+        # allow delta- prefix for existing delta voices: validate suffix
+        if voicename.lower().startswith("delta-"):
+            suffix = voicename[6:]
+            if _sanitize_delta_component(suffix) is None and suffix != "":
+                _fail(f"  ✗ Invalid voice name '{voicename}'. Use letters, numbers, hyphens, underscores (no /, \\, or dots).")
+            # also block bare delta- name without suffix?
+            if not suffix:
+                _fail(f"  ✗ Invalid voice name '{voicename}'. Use letters, numbers, hyphens, underscores (no /, \\, or dots).")
+        else:
+            _fail(f"  ✗ Invalid voice name '{voicename}'. Use letters, numbers, hyphens, underscores (no /, \\, or dots).")
+    # resolve voice
+    voice_path, voice_meta = _registry_resolve(voicename)
+    if voice_path is None or not voice_path.exists():
+        _fail(f"  ✗ Voice '{voicename}' not found. Try voice list")
+    # voice_meta may be None if direct path; need to load from folder
+    if voice_meta is None:
+        # try to load voice.json from parent folder
+        maybe_json = Path(voice_path).parent / "voice.json"
+        if maybe_json.exists():
+            try:
+                voice_meta = json.loads(maybe_json.read_text())
+            except Exception:
+                voice_meta = {}
+        else:
+            voice_meta = {}
+    source_hf = voice_meta.get("source_hf_model") or voice_meta.get("source") or "—"
+    _say(f"  '{voicename}' is {source_hf}")
+
+    # detect base
+    suggested, is_multi, count, raw_list = _detect_base(source_hf)
+    if suggested is None:
+        # ask user to enter base manually if detection failed
+        _say(f"  Base detected: unknown")
+        try:
+            entered = input(f"  Enter base HF repo [ ]: ").strip()
+        except (EOFError, KeyboardInterrupt):
+            _say("  ⚠ Cancelled.")
+            sys.exit(0)
+        norm = _normalize_hf_repo(entered) if entered else None
+        if not norm:
+            _fail("  ✗ Invalid base repo.")
+        suggested = norm
+        is_multi = False
+        count = 1
+    else:
+        if is_multi:
+            _say(f"  Card lists {count} bases, suggested: {suggested}")
+        else:
+            _say(f"  Base detected: {suggested}")
+
+    # prompt for base choice
+    try:
+        entered = input(f"  Press enter to use {suggested} or enter another HF repo [ {suggested} ]: ").strip()
+    except (EOFError, KeyboardInterrupt):
+        _say("  ⚠ Cancelled.")
+        sys.exit(0)
+    if not entered:
+        base_id = suggested
+    else:
+        norm = _normalize_hf_repo(entered)
+        if norm is None:
+            _fail(f"  ✗ Invalid HF repo '{entered}'. Use org/model or https://huggingface.co/org/model")
+        base_id = norm
+
+    # Normalize base_id to org/model
+    norm_base = _normalize_hf_repo(base_id)
+    if norm_base is None:
+        _fail(f"  ✗ Invalid base repo '{base_id}'.")
+    base_id = norm_base
+
+    # Determine delta name lowercased
+    delta_name = f"delta-{voicename.lower()}"
+    # P0-3: sanitize delta_name component (reject /\)
+    if "/" in delta_name or "\\" in delta_name:
+        _fail(f"  ✗ Invalid voice name '{delta_name}'. Use letters, numbers, hyphens, underscores (no /, \\, or dots).")
+    delta_folder = VOICES_DIR / delta_name
+    # P0-1 / HIG P0-4: Overwrite guard before heavy work (like cmd_get)
+    if delta_folder.exists() and (delta_folder / "voice.safetensors").exists():
+        try:
+            ans = input(f"  Voice '{delta_name}' already exists. Overwrite? [y/N]: ").strip().lower()
+        except (EOFError, KeyboardInterrupt):
+            _say("  ⚠ Cancelled.")
+            sys.exit(0)
+        if ans not in ("y", "yes"):
+            _say("  Cancelled.")
+            sys.exit(0)
+    # check base cache
+    bps = _base_paths(base_id)
+    if bps is None:
+        _fail(f"  ✗ Invalid base repo '{base_id}'.")
+    b_file, b_json, b_nested_dir, b_nested_file, b_nested_json = bps
+
+    # decide if base exists
+    base_exists = b_file.exists() or b_nested_file.exists()
+    # prefer file_path existence; but check json for bytes
+    existing_meta = None
+    existing_path = None
+    if b_file.exists():
+        existing_path = b_file
+        if b_json.exists():
+            try:
+                existing_meta = json.loads(b_json.read_text())
+            except Exception:
+                existing_meta = None
+    elif b_nested_file.exists():
+        existing_path = b_nested_file
+        if b_nested_json.exists():
+            try:
+                existing_meta = json.loads(b_nested_json.read_text())
+            except Exception:
+                existing_meta = None
+
+    # if exists, check for update via remote header size
+    if base_exists and existing_meta is not None:
+        try:
+            _say(f"  ✦ Checking base cache ({base_id})...")
+            remote = _fetch_base_head_info(base_id)
+            if remote is not None:
+                _, _, _, _, r_info = remote
+                r_begin, r_end = r_info["data_offsets"]
+                remote_bytes = r_end - r_begin
+                # P1-5 bytes missing fallback: graceful handling
+                _local_bytes_raw = existing_meta.get("bytes")
+                if _local_bytes_raw is None:
+                    _local_bytes_raw = existing_meta.get("file_bytes")
+                if isinstance(_local_bytes_raw, int):
+                    local_bytes = _local_bytes_raw
+                else:
+                    # missing or invalid -> treat as 0 and skip update prompt gracefully
+                    local_bytes = 0
+                    if VERBOSE:
+                        _say(f"  ⚠ local bytes missing for {base_id}, assuming 0")
+                if remote_bytes != local_bytes:
+                    # confirm same HF repo and link (P1-4: remove or True tautology)
+                    same_repo = (existing_meta.get("source_hf_model","").lower() == base_id.lower()) or (base_id.lower() in existing_meta.get("repo","").lower())
+                    if same_repo:
+                        try:
+                            ans = input(f"  Base {base_id} exists but update is available (online {remote_bytes/1e6:.1f} MB vs local {local_bytes/1e6:.1f} MB) — update? [y/N]: ").strip().lower()
+                        except (EOFError, KeyboardInterrupt):
+                            _say("  ⚠ Cancelled.")
+                            sys.exit(0)
+                        if ans in ("y","yes"):
+                            _say(f"  ✦ Updating base {base_id}...")
+                            _download_base_tensor(base_id)
+                            if b_json.exists():
+                                try:
+                                    existing_meta = json.loads(b_json.read_text())
+                                except Exception:
+                                    pass
+                            existing_path = b_file if b_file.exists() else b_nested_file
+                        else:
+                            _say(f"  Keeping cached base.")
+                    else:
+                        if VERBOSE:
+                            _say(f"  ⚠ remote base mismatch, keeping cached")
+        except Exception as e:
+            if VERBOSE:
+                _say(f"  ⚠ update check failed: {e}")
+            else:
+                # HIG P1-4: network errors silent -> add VERBOSE warning already, but also subtle hint
+                pass
+    # if not exists, download
+    if not (b_file.exists() or b_nested_file.exists()):
+        _download_base_tensor(base_id)
+        if b_file.exists():
+            existing_path = b_file
+        else:
+            existing_path = b_nested_file
+    else:
+        # ensure paths exist after possible update; otherwise already have
+        if not b_file.exists() and b_nested_file.exists():
+            # copy nested to file for spec compliance
+            try:
+                b_file.parent.mkdir(parents=True, exist_ok=True)
+                import shutil as _sh
+                _sh.copy2(str(b_nested_file), str(b_file))
+                if b_nested_json.exists() and not b_json.exists():
+                    _sh.copy2(str(b_nested_json), str(b_json))
+            except Exception:
+                pass
+        existing_path = b_file if b_file.exists() else b_nested_file
+
+    # Now we have voice and base ready; compute delta
+    # Load voice header
+    _say(f"  ✦ Crafting your style...")
+    try:
+        v_header, v_tensors = read_safetensors(str(voice_path))
+    except ValueError as exc:
+        _fail(f"  ✗ {exc}")
+    v_tname = list(v_tensors.keys())[0]
+    v_info = v_tensors[v_tname]
+    v_dtype = v_info["dtype"]
+    v_shape = tuple(v_info["shape"])
+    v_begin, v_end = v_info["data_offsets"]
+    # base header
+    try:
+        b_header, b_tensors = read_safetensors(str(existing_path))
+    except ValueError as exc:
+        _fail(f"  ✗ base file invalid: {exc}")
+    b_tname = list(b_tensors.keys())[0]
+    b_info = b_tensors[b_tname]
+    b_dtype = b_info["dtype"]
+    b_shape = tuple(b_info["shape"])
+    b_begin, b_end = b_info["data_offsets"]
+    if v_shape != b_shape:
+        _say(f"  ✗ This voice doesn't fit this base. It's made for a different size of model, so they won't blend.")
+        if VERBOSE:
+            _say(f"    Voice shape: {v_shape} ({v_dtype})")
+            _say(f"    Base shape:  {b_shape} ({b_dtype})")
+        sys.exit(1)
+
+    # Prepare output: F16 delta
+    total_elems = 1
+    for d in v_shape:
+        total_elems *= int(d)
+    out_dtype = "F16"
+    out_shape = v_shape
+    out_tensor_name = v_tname  # keep original name; delta same shape
+    # Delta uses same tensor name, but we note style.delta compatibility; keep original
+    # For spec, dtype F16
+    header_out = {out_tensor_name: {"dtype": out_dtype, "shape": list(out_shape), "data_offsets": [0, total_elems*2]}}
+    hj = json.dumps(header_out).encode()
+
+    # P0-1 overwrite already prompted above; now create folder
+    delta_folder.mkdir(parents=True, exist_ok=True)
+    out_path = delta_folder / "voice.safetensors"
+    # Open files and compute chunked 1M elems
+    chunk_elems = 1 << 20  # 1M
+    # Determine bytes per elem for each dtype
+    def _dtype_bytes(dt):
+        dt = dt.upper()
+        if dt in ("F32","FP32"):
+            return 4
+        return 2  # F16, BF16
+    v_bpe = _dtype_bytes(v_dtype)
+    b_bpe = _dtype_bytes(b_dtype)
+
+    # Need header sizes to locate data
+    with open(voice_path, "rb") as fv:
+        v_hs = struct.unpack("<Q", fv.read(8))[0]
+        # we already have v_header, but need data start: 8+v_hs
+        v_data_start = 8 + v_hs + v_begin
+    with open(existing_path, "rb") as fb:
+        b_hs = struct.unpack("<Q", fb.read(8))[0]
+        b_data_start = 8 + b_hs + b_begin
+
+    # Chunked processing
+    import shutil as _shutil
+    # We'll write header then stream
+    with open(voice_path, "rb") as fs, open(existing_path, "rb") as fb, open(out_path, "wb") as out:
+        out.write(struct.pack("<Q", len(hj)))
+        out.write(hj)
+        fs.seek(v_data_start)
+        fb.seek(b_data_start)
+        processed = 0
+        while processed < total_elems:
+            cur = min(chunk_elems, total_elems - processed)
+            # read cur * bpe
+            v_bytes = fs.read(cur * v_bpe)
+            b_bytes = fb.read(cur * b_bpe)
+            if len(v_bytes) != cur * v_bpe or len(b_bytes) != cur * b_bpe:
+                _fail(f"  ✗ Short read during delta compute")
+            # decode to f32
+            # voice
+            vu = v_dtype.upper()
+            if vu in ("BF16","BF16E8M"):
+                v_u16 = np.frombuffer(v_bytes, dtype=np.uint16)
+                v_f32 = _bf16_to_f32(v_u16)
+            elif vu in ("F16","FP16","F16E5M6"):
+                v_f32 = np.frombuffer(v_bytes, dtype=np.float16).astype(np.float32)
+            elif vu in ("F32","FP32"):
+                v_f32 = np.frombuffer(v_bytes, dtype=np.float32).astype(np.float32)
+            else:
+                _fail(f"  ✗ Unsupported voice dtype {v_dtype}")
+            # base
+            bu = b_dtype.upper()
+            if bu in ("BF16","BF16E8M"):
+                b_u16 = np.frombuffer(b_bytes, dtype=np.uint16)
+                b_f32 = _bf16_to_f32(b_u16)
+            elif bu in ("F16","FP16","F16E5M6"):
+                b_f32 = np.frombuffer(b_bytes, dtype=np.float16).astype(np.float32)
+            elif bu in ("F32","FP32"):
+                b_f32 = np.frombuffer(b_bytes, dtype=np.float32).astype(np.float32)
+            else:
+                _fail(f"  ✗ Unsupported base dtype {b_dtype}")
+            delta_f32 = v_f32 - b_f32
+            delta_f16 = delta_f32.astype(np.float16)
+            out.write(delta_f16.tobytes())
+            processed += cur
+            if VERBOSE and processed % (10<<20) < chunk_elems:
+                _say(f"  {processed/total_elems*100:.1f}% {processed}/{total_elems}")
+
+    # Save delta metadata
+    from datetime import datetime, timezone
+    # Try to fetch base shard url from base meta if exists
+    base_meta = None
+    if b_json.exists():
+        try:
+            base_meta = json.loads(b_json.read_text())
+        except Exception:
+            base_meta = None
+    if base_meta is None and b_nested_json.exists():
+        try:
+            base_meta = json.loads(b_nested_json.read_text())
+        except Exception:
+            base_meta = None
+    shard_url = base_meta.get("shard_url") if base_meta else ""
+    if base_meta:
+        _bb = base_meta.get("bytes")
+        if _bb is None:
+            _bb = base_meta.get("file_bytes")
+        base_bytes = _bb if isinstance(_bb, int) else 0
+    else:
+        base_bytes = 0
+    # voice.json for delta
+    # read voice shape etc already
+    meta = {
+        "name": delta_name,
+        "type": "delta",
+        "source": voicename,
+        "source_hf_model": source_hf,
+        "base": base_id,
+        "base_bytes": base_bytes,
+        "shard_url": shard_url,
+        "etag": base_meta.get("etag") if base_meta else None,
+        "shape": list(v_shape),
+        "dtype": "F16",
+        "tensor_name": out_tensor_name,
+        "bytes": total_elems*2,
+        "downloaded_at": datetime.now(timezone.utc).isoformat(),
+        "base_file": str(existing_path),
+    }
+    (delta_folder / "voice.json").write_text(json.dumps(meta, indent=2) + "\n")
+
+    file_size = os.path.getsize(out_path)
+    _say(f"  ✦ Done → {delta_folder}")
+    _say(f"  Delta {delta_name} ({file_size/1e6:.1f} MB) from {voicename} − {base_id}")
+    _say(f"  Base cached at: {existing_path}")
+    _say(f"  Use it: voice cast <your-model.gguf> {delta_name}")
+
+
+# ---------------------------------------------------------------------------
+#  CMD: info — show voice metadata elegantly
+# ---------------------------------------------------------------------------
+
+def cmd_info(args):
+    voicename = args.voicename.strip()
+    voice_path, voice_meta = _registry_resolve(voicename)
+    if voice_path is None or not voice_path.exists():
+        # also check base? base is not voice, but we support base info via base name?
+        # try base dir lookup
+        bps = _base_paths(voicename)
+        if bps is not None:
+            b_file, b_json, _, b_nested_file, b_nested_json = bps
+            # check if base exists
+            target_json = None
+            target_file = None
+            if b_file.exists() and b_json.exists():
+                target_json = b_json
+                target_file = b_file
+            elif b_nested_file.exists() and b_nested_json.exists():
+                target_json = b_nested_json
+                target_file = b_nested_file
+            if target_json is not None:
+                try:
+                    meta = json.loads(target_json.read_text())
+                    _say(f"  Name:    {voicename}")
+                    _say(f"  Source:  https://huggingface.co/{meta.get('source_hf_model','—')} ({meta.get('source_hf_model','—')})")
+                    _say(f"  Type:    base")
+                    if VERBOSE:
+                        _say(f"  Shape:   {meta.get('shape','—')}")
+                        _say(f"  Dtype:   {meta.get('dtype','—')}")
+                        _say(f"  Tensor:  {meta.get('tensor_name','—')}")
+                    # P0-2: elegant bytes via 1409 logic
+                    _bv = meta.get("bytes")
+                    if _bv is None:
+                        _bv = meta.get("file_bytes")
+                    if isinstance(_bv, int):
+                        _say(f"  Bytes:   {_bv} ({_bv/1e6:.1f} MB)")
+                    elif _bv is not None:
+                        _say(f"  Bytes:   {_bv}")
+                    else:
+                        _say(f"  Bytes:   —")
+                    # P0-2: ETag display
+                    _etag = meta.get("etag")
+                    if _etag:
+                        _etag_disp = str(_etag)[:64] + "…" if len(str(_etag)) > 64 else str(_etag)
+                        _say(f"  ETag:    {_etag_disp}")
+                    else:
+                        _say(f"  ETag:    —")
+                    _say(f"  Fetched: {meta.get('fetched_at','—')}")
+                    _say(f"  License: {meta.get('license','—') if meta.get('license') else '—'}")
+                    _say(f"  File:    {target_file}")
+                    _say(f"  Repo:    {meta.get('repo','https://huggingface.co/'+voicename)}")
+                    return
+                except Exception as e:
+                    if VERBOSE:
+                        _say(f"  ⚠ unreadable base metadata: {e}")
+                    pass
+        _fail(f"  ✗ Voice '{voicename}' not found. Try voice list")
+
+    # load meta if missing
+    if voice_meta is None:
+        meta_path = Path(voice_path).parent / "voice.json"
+        if meta_path.exists():
+            try:
+                voice_meta = json.loads(meta_path.read_text())
+            except Exception:
+                voice_meta = {}
+        else:
+            voice_meta = {}
+    # Ensure we have metadata dict
+    meta = voice_meta or {}
+    # Try to load from voice.json file for complete data
+    folder = Path(voice_path).parent
+    json_path = folder / "voice.json"
+    if json_path.exists():
+        try:
+            file_meta = json.loads(json_path.read_text())
+            # merge
+            for k,v in file_meta.items():
+                if k not in meta:
+                    meta[k] = v
+                else:
+                    # prefer file_meta
+                    meta[k] = v
+        except Exception:
+            pass
+
+    def _tr(s, w):
+        s = str(s)
+        return s[: w - 1] + "…" if len(s) > w else s
+
+    name = meta.get("name", voicename)
+    source = meta.get("source_hf_model", meta.get("source", "—"))
+    typ = meta.get("type", "voice")
+    shape = meta.get("shape", "—")
+    dtype = meta.get("dtype", "—")
+    tensor = meta.get("tensor_name", meta.get("tensor", "—"))
+    fetched = meta.get("downloaded_at", meta.get("fetched_at", "—"))
+    license_text = meta.get("license", "—")
+    base = meta.get("base", None)
+    # P1-5 / P0-2: bytes missing fallback + elegant formatting
+    bytes_val = meta.get("bytes")
+    if bytes_val is None:
+        bytes_val = meta.get("file_bytes")
+    if isinstance(bytes_val, int):
+        bytes_str = f"{bytes_val} ({bytes_val/1e6:.1f} MB)"
+    elif bytes_val is not None:
+        bytes_str = str(bytes_val)
+    else:
+        bytes_str = "—"
+
+    # Elegant multiline (HIG polished)
+    _say(f"  Name:    {_tr(name, 30)}")
+    _say(f"  Source:  https://huggingface.co/{source} ({_tr(source,40)})")
+    if base:
+        _say(f"  Base:    https://huggingface.co/{base} ({_tr(base,40)})")
+        # try to show base local path if exists
+        bps2 = _base_paths(base)
+        if bps2 is not None:
+            bf, bj, _, _, _ = bps2
+            if bf.exists():
+                _say(f"  Base file: {bf}")
+    _say(f"  Type:    {typ}")
+    # Shape/Dtype/Tensor gated under VERBOSE (HIG P1-3 unified)
+    if VERBOSE:
+        _say(f"  Shape:   {shape}")
+        _say(f"  Dtype:   {dtype}")
+        _say(f"  Tensor:  {tensor}")
+    _say(f"  Bytes:   {bytes_str}")
+    # P0-2: ETag display (show — if missing, truncate for elegance)
+    _etag = meta.get("etag")
+    if _etag:
+        _etag_str = str(_etag)
+        _etag_disp = _etag_str[:64] + "…" if len(_etag_str) > 64 else _etag_str
+        _say(f"  ETag:    {_etag_disp}")
+    else:
+        _say(f"  ETag:    —")
+    _say(f"  Fetched: {fetched}")
+    if license_text and license_text != "—":
+        # truncate long license
+        lic = license_text[:200] if len(license_text) > 200 else license_text
+        _say(f"  License: {lic}")
+    else:
+        _say(f"  License: —")
+    # Also show file location
+    _say(f"  File:    {voice_path}")
+
+
+
+# ---------------------------------------------------------------------------
+#  CMD: list
+# ---------------------------------------------------------------------------
+
+def cmd_list(_args):
+    # voice list base → list cached bases
+    if getattr(_args, "target", None) == "base":
+        base_root = VOICES_DIR / "base"
+        if not base_root.exists() or not any(base_root.rglob("*.json")):
+            _say("  No bases cached yet.  Use 'voice delta <voice>' to fetch one.")
+            return
+
+        def _tr(s, w):
+            s = str(s)
+            return s[: w - 1] + "…" if len(s) > w else s
+
+        _say(f"  {_tr('Base', 40):<40} {_tr('Bytes', 18):<18} {_tr('Fetched', 12):<12}")
+        _say(f"  {'─'*40} {'─'*18} {'─'*12}")
+        seen = set()
+        for jpath in sorted(base_root.rglob("*.json")):
+            try:
+                meta = json.loads(jpath.read_text())
+            except (json.JSONDecodeError, ValueError):
+                continue
+            # derive base id - support both layouts but dedupe to org/model
+            rel = jpath.relative_to(base_root)
+            parts = rel.parts
+            if len(parts) == 2:
+                base_id = f"{parts[0]}/{Path(parts[1]).stem}"
+            elif len(parts) == 3 and parts[2] == "base.json":
+                base_id = f"{parts[0]}/{parts[1]}"
+            else:
+                base_id = str(rel.with_suffix("")).replace(os.sep, "/")
+                if base_id.endswith("/base"):
+                    base_id = base_id[:-5]
+            if base_id in seen:
+                continue
+            seen.add(base_id)
+            b = meta.get("bytes")
+            if b is None:
+                b = meta.get("file_bytes")
+            if isinstance(b, int):
+                b_str = f"{b} ({b/1e6:.1f} MB)"
+            else:
+                b_str = "—"
+            fetched = meta.get("fetched_at", "—")[:10] if isinstance(meta.get("fetched_at"), str) else "—"
+            _say(f"  {_tr(base_id, 40):<40} {_tr(b_str, 18):<18} {_tr(fetched, 12):<12}")
+            if VERBOSE:
+                _say(f"    {jpath}")
+        return
+
+    if not VOICES_DIR.exists() or not any(VOICES_DIR.iterdir()):
+        _say("  No voices stored yet.  Use 'voice get <model>' to save one.")
+        return
+
+    def _tr(s, w):
+        s = str(s)
+        return s[: w - 1] + "…" if len(s) > w else s
+
+    _say(f"  {_tr('Name', 30):<30} {_tr('Source', 40):<40} {_tr('Type', 8):<8}")
+    _say(f"  {'─'*30} {'─'*40} {'─'*8}")
+    for d in sorted(VOICES_DIR.iterdir()):
+        if not d.is_dir():
+            continue
+        if d.name == "base":
+            continue
+        meta_path = d / "voice.json"
+        if not meta_path.exists():
+            _say(f"  {_tr(d.name, 30):<30} {_tr('(no metadata)', 40):<40} {_tr('⚠', 8):<8}")
+            if VERBOSE:
+                _say(f"    ⚠ missing metadata: {meta_path}")
+            continue
+        try:
+            meta = json.loads(meta_path.read_text())
+        except (json.JSONDecodeError, ValueError) as e:
+            _say(f"  {_tr(d.name, 30):<30} {_tr('⚠ unreadable metadata', 40):<40} {_tr('⚠', 8):<8}")
+            if VERBOSE:
+                _say(f"    ⚠ unreadable metadata: {meta_path} ({e})")
+            continue
+        name = meta.get("name", d.name)
+        src = meta.get("source_hf_model", meta.get("source", "—"))
+        typ = meta.get("type", "voice")
+        _say(f"  {_tr(name, 30):<30} {_tr(src, 40):<40} {_tr(typ, 8):<8}")
+
+
+# ---------------------------------------------------------------------------
+#  CMD: remove
+# ---------------------------------------------------------------------------
+
+def cmd_remove(args):
+    name = args.voice.strip().lower()
+    if not VOICES_DIR.exists():
+        _fail(f"  ✗ Voice '{args.voice}' not found.")
+    target = None
+    for d in VOICES_DIR.iterdir():
+        if d.is_dir() and d.name.lower() == name:
+            target = d
+            break
+    if target is None:
+        _fail(f"  ✗ Voice '{args.voice}' not found.")
+    try:
+        ans = input(f"  Remove voice '{target.name}'? [y/N]: ").strip().lower()
+    except (EOFError, KeyboardInterrupt):
+        _say("  ⚠ Cancelled.")
+        sys.exit(0)
+    if ans not in ("y", "yes"):
+        _say("  Cancelled.")
+        sys.exit(0)
+    import shutil
+    shutil.rmtree(target)
+    _say(f"  ✦ Removed '{target.name}'.")
+
+
+# ---------------------------------------------------------------------------
+#  CMD: path — put `voice` on your PATH
+# ---------------------------------------------------------------------------
+
+def _is_command(name):
+    import shutil
+    return shutil.which(name) is not None
+
+
+def cmd_path(_args):
+    import shutil
+    from pathlib import Path as _Path
+
+    script = _Path(__file__).resolve().parent / "voice.py"
+    # fallback to "voice" wrapper if voice.py missing (shim compatibility)
+    if not script.exists():
+        alt = _Path(__file__).resolve().parent / "voice"
+        if alt.exists():
+            script = alt
+        else:
+            _fail("  ✗ Can't find the voice script next to voice.py. Check your installation.")
+
+    if sys.platform.startswith("win"):
+        if _is_command("voice"):
+            _say("  ✦ Voice is already on your PATH — you're good to go.")
+            return
+        target_dir = _Path(os.environ.get("LOCALAPPDATA", ""))
+        if target_dir == _Path(""):
+            _fail("  ✗ Couldn't find a Windows app-data folder to install into.")
+        bindir = target_dir / "voice-cli"
+        bindir.mkdir(parents=True, exist_ok=True)
+        script_new = bindir / "voice.py"
+        shutil.copy2(str(script), str(script_new))
+        _say(f"  ✦ Voice is ready on your PATH.")
+        _say(f"  Add this to your PATH (in PowerShell):")
+        _say(f"    setx PATH \"%PATH%;{bindir}\"")
+        _say(f"  Then open a new terminal and run: voice help")
+        return
+
+    # Unix (Linux / macOS)
+    candidates = [
+        _Path("/usr/local/bin"),
+        _Path.home() / ".local" / "bin",
+        _Path("/usr/bin"),
+        _Path("/bin"),
+    ]
+    on_path = next(
+        (d for d in candidates if d.is_dir() and str(d) in os.environ.get("PATH", "").split(":")),
+        None,
+    )
+    if _is_command("voice"):
+        _say("  ✦ Voice is already on your PATH — you're good to go.")
+        return
+    if on_path is None:
+        _fail("  ✗ No writable directory on PATH found. Add /Lora to your PATH manually.")
+    target = on_path / "voice"
+    try:
+        target.symlink_to(str(script))
+    except FileExistsError:
+        target.unlink()
+        target.symlink_to(str(script))
+    except (PermissionError, OSError):
+        if VERBOSE:
+            import traceback as _tb
+            _say(f"  Details: {_tb.format_exc().strip()}")
+        _fail(
+            f"  ✗ Couldn't create a link in {on_path}. "
+            f"Try: sudo ln -s {script} {target}"
+        )
+    _say(f"  ✦ Voice is ready at {target}. Open a new terminal and run: voice")
+
+
+# ---------------------------------------------------------------------------
+#  Main CLI
+# ---------------------------------------------------------------------------
+
+def main():
+    global VERBOSE
+
+    parser = argparse.ArgumentParser(
+        prog="voice",
+        description="Get a voice, then cast it onto your model.",
+    )
+    parser.add_argument(
+        "-v", "--verbose", action="store_true", help="Show detailed progress"
+    )
+    sub = parser.add_subparsers(dest="command")
+
+    p_get = sub.add_parser("get", help="Get a voice from a HuggingFace model")
+    p_get.add_argument(
+        "model_id", help="HuggingFace model ID (e.g. google/gemma-3-1b)"
+    )
+    p_get.add_argument(
+        "-q", "--quiet", action="store_true", help="Skip license detection"
+    )
+
+    p_cast = sub.add_parser(
+        "cast", help="Cast a voice onto your model"
+    )
+    p_cast.add_argument("target_gguf", help="Path to the target GGUF model")
+    p_cast.add_argument(
+        "voice", help="Voice name (from registry) or path to .safetensors"
+    )
+    p_cast.add_argument(
+        "--out",
+        help="Output directory or file (default: ./<model>/<voice>-<model>.gguf)",
+    )
+
+    sub.add_parser("path", help="Add 'voice' to your system PATH")
+
+    p_rm = sub.add_parser("remove", help="Remove a stored voice")
+    p_rm.add_argument("voice", help="Voice name to remove")
+
+    p_list = sub.add_parser("list", help="List stored voices")
+    p_list.add_argument("target", nargs="?", choices=["base"], help="List bases instead of voices (voice list base)")
+
+    p_delta = sub.add_parser("delta", help="Make a style you can re-use (voice − base)")
+    p_delta.add_argument("voicename", nargs="?", help="Voice name from registry (from voice list)")
+
+    p_info = sub.add_parser("info", help="Show voice metadata")
+    p_info.add_argument("voicename", help="Voice name to show info for")
+
+    args = parser.parse_args()
+    VERBOSE = args.verbose
+
+    if args.command is None:
+        print("Get a voice, then cast it onto your model.\n")
+        parser.print_help()
+        sys.exit(0)
+
+    if args.command == "get":
+        cmd_get(args)
+    elif args.command == "cast":
+        cmd_cast(args)
+    elif args.command == "list":
+        cmd_list(args)
+    elif args.command == "path":
+        cmd_path(args)
+    elif args.command == "remove":
+        cmd_remove(args)
+    elif args.command == "delta":
+        cmd_delta(args)
+    elif args.command == "info":
+        cmd_info(args)
+
+
+if __name__ == "__main__":
+    main()