Update voice.py, vlib, tests, bundles

tests/_helpers.py

@@ -91,6 +91,9 @@ class IsolatedVoices(unittest.TestCase):
         self._old = voice.VOICES_DIR
         self.vdir = Path(tempfile.mkdtemp(prefix="voices-"))
         voice.VOICES_DIR = self.vdir
+        voice_ctx = sys.modules.get("vlib.ctx")
+        if voice_ctx is not None:
+            voice_ctx.VOICES_DIR = self.vdir
         # registry + reports + parts all derive from VOICES_DIR at call time,
         # except these module constants: repoint them too.
         self._old_reports = (voice.REPORTS_JSONL, voice.REPORTS_OUTBOX, voice.OPERATIONS_LOG,
@@ -99,11 +102,21 @@ class IsolatedVoices(unittest.TestCase):
         voice.REPORTS_OUTBOX = self.vdir / "outbox"
         voice.OPERATIONS_LOG = self.vdir / "operations.log"
         voice.HF_TOKEN_PATH = self.vdir / ".hf_token"
+        if voice_ctx is not None:
+            voice_ctx.REPORTS_JSONL = voice.REPORTS_JSONL
+            voice_ctx.REPORTS_OUTBOX = voice.REPORTS_OUTBOX
+            voice_ctx.OPERATIONS_LOG = voice.OPERATIONS_LOG
+            voice_ctx.HF_TOKEN_PATH = voice.HF_TOKEN_PATH
 
     def tearDown(self):
         voice.VOICES_DIR = self._old
         (voice.REPORTS_JSONL, voice.REPORTS_OUTBOX, voice.OPERATIONS_LOG,
          voice.HF_TOKEN_PATH) = self._old_reports
+        voice_ctx = sys.modules.get("vlib.ctx")
+        if voice_ctx is not None:
+            voice_ctx.VOICES_DIR = self._old
+            (voice_ctx.REPORTS_JSONL, voice_ctx.REPORTS_OUTBOX, voice_ctx.OPERATIONS_LOG,
+             voice_ctx.HF_TOKEN_PATH) = self._old_reports
 
 
 def ns(**kw):

tests/test_units.py

@@ -1,5 +1,6 @@
 """Offline unit tests: pure logic, no network. Must stay fast (<60s total)."""
 import json
+import os
 import struct
 import sys
 import tempfile
@@ -8,6 +9,7 @@ from pathlib import Path
 
 sys.path.insert(0, str(Path(__file__).resolve().parent))
 from _helpers import IsolatedVoices, ns, voice  # noqa: E402
+from vlib.pack import _resolve_pack_tensors  # noqa: E402
 
 import numpy as np
 
@@ -55,6 +57,25 @@ class TestNames(unittest.TestCase):
         with self.assertRaises(SystemExit):
             voice._resolve_name(ns(name="bad name!"), "fallback")
 
+    def test_public_source_passthrough(self):
+        for good in ("org/model", "google/gemma-4-12b", "model.gguf",
+                     "voice-name", "", "—"):
+            self.assertEqual(voice._public_source(good), good, good)
+
+    def test_public_source_strips_local_paths(self):
+        self.assertEqual(
+            voice._public_source("/Users/someone/Downloads/m.gguf"), "m.gguf")
+        self.assertEqual(voice._public_source("./rel/m.gguf"), "m.gguf")
+        self.assertEqual(voice._public_source("~/m.gguf"), "m.gguf")
+
+    def test_public_source_strips_url_secrets(self):
+        self.assertEqual(
+            voice._public_source("https://user:pw@huggingface.co/o/m"),
+            "https://huggingface.co/o/m")
+        self.assertEqual(
+            voice._public_source("https://cdn.example/x.bin?sig=SECRET&t=1"),
+            "https://cdn.example/x.bin")
+
     def test_registry_folder_lowercases(self):
         self.assertTrue(str(voice._registry_folder("StyleTune-V2")).endswith("styletune-v2"))
 
@@ -271,7 +292,163 @@ class TestDeltaGates(unittest.TestCase):
         v, b = self._pair(d)
         out = voice._compute_delta(str(v), str(b), d / "out", "delta-x", ns())
         got = read_arr(out, "output.weight")
-        self.assertTrue((got == 1.0).all())
+        self.assertTrue((got == 1.0).all(), "delta must equal voice(2.0) - base(1.0)")
+
+    def test_tied_base_head_falls_back_to_embed(self):
+        import io
+        from contextlib import redirect_stdout
+        d = Path(tempfile.mkdtemp())
+        v, b = d / "v.safetensors", d / "b.safetensors"
+        write_st(v, {"lm_head.weight": (np.full((4, 4), 2.0, dtype=np.float16), "F16"),
+                     "model.language_model.embed_tokens.weight": (np.full((4, 4), 7.0, dtype=np.float16), "F16")})
+        write_st(b, {"model.language_model.embed_tokens.weight": (np.full((4, 4), 1.0, dtype=np.float16), "F16")})
+        buf = io.StringIO()
+        with redirect_stdout(buf):
+            out = voice._compute_delta(str(v), str(b), d / "out", "delta-x", ns())
+        self.assertTrue((read_arr(out, "lm_head.weight") == 1.0).all(), "head delta must equal voice head(2.0) - tied base embed(1.0)")
+        self.assertTrue((read_arr(out, "model.language_model.embed_tokens.weight") == 6.0).all(), "embed delta must equal voice embed(7.0) - base embed(1.0)")
+        self.assertIn("tied", buf.getvalue(), "fallback must be loud, not silent")
+
+    def test_tied_base_shape_mismatch_fails(self):
+        d = Path(tempfile.mkdtemp())
+        v, b = d / "v.safetensors", d / "b.safetensors"
+        write_st(v, {"lm_head.weight": (np.full((4, 4), 2.0, dtype=np.float16), "F16")})
+        write_st(b, {"model.language_model.embed_tokens.weight": (np.full((4, 8), 1.0, dtype=np.float16), "F16")})
+        with self.assertRaises(SystemExit):
+            voice._compute_delta(str(v), str(b), d / "out", "delta-x", ns())
+
+    def test_headless_baseless_still_fails(self):
+        d = Path(tempfile.mkdtemp())
+        v, b = d / "v.safetensors", d / "b.safetensors"
+        write_st(v, {"lm_head.weight": (np.full((4, 4), 2.0, dtype=np.float16), "F16")})
+        write_st(b, {"blk.0.attn.weight": (np.full((4, 4), 1.0, dtype=np.float16), "F16")})
+        with self.assertRaises(SystemExit):
+            voice._compute_delta(str(v), str(b), d / "out", "delta-x", ns())
+
+    def test_tied_head_want_reroutes_to_embed(self):
+        d = Path(tempfile.mkdtemp())
+        b = d / "tied.safetensors"
+        write_st(b, {"model.language_model.embed_tokens.weight": (np.full((4, 4), 1.0, dtype=np.float16), "F16")})
+        self.assertEqual(voice._tied_head_want(str(b), None, ["lm_head.weight"]),
+                         ["model.language_model.embed_tokens.weight"])
+
+    def test_tied_head_want_dedupes_embed(self):
+        d = Path(tempfile.mkdtemp())
+        b = d / "tied.safetensors"
+        write_st(b, {"model.language_model.embed_tokens.weight": (np.full((4, 4), 1.0, dtype=np.float16), "F16")})
+        self.assertEqual(voice._tied_head_want(str(b), None,
+                         ["lm_head.weight", "model.language_model.embed_tokens.weight"]),
+                         ["model.language_model.embed_tokens.weight"])
+
+    def test_tied_head_want_untied_unchanged(self):
+        d = Path(tempfile.mkdtemp())
+        b = d / "untied.safetensors"
+        write_st(b, {"lm_head.weight": (np.full((4, 4), 1.0, dtype=np.float16), "F16"),
+                     "model.language_model.embed_tokens.weight": (np.full((4, 4), 1.0, dtype=np.float16), "F16")})
+        self.assertEqual(voice._tied_head_want(str(b), None, ["lm_head.weight"]), ["lm_head.weight"])
+
+    def test_tied_head_want_headless_unchanged(self):
+        d = Path(tempfile.mkdtemp())
+        b = d / "bare.safetensors"
+        write_st(b, {"blk.0.attn.weight": (np.full((4, 4), 1.0, dtype=np.float16), "F16")})
+        self.assertEqual(voice._tied_head_want(str(b), None, ["lm_head.weight"]), ["lm_head.weight"])
+
+    def test_gguf_delta_chunked_matches_full(self):
+        # Slow path (either side GGUF) must stream dequant in bounded chunks:
+        # patch the seam small + unaligned, spy max slice, assert values equal
+        # full-dequant math and every slice bounded by the seam.
+        from gguf import GGUFWriter
+        from gguf.constants import GGMLQuantizationType as Q
+        from gguf.quants import quantize
+        d = Path(tempfile.mkdtemp())
+        shape = (64, 128)
+        rng = np.random.default_rng(7)
+        vf = (rng.normal(size=shape) * 2).astype(np.float32)
+        bf = (rng.normal(size=shape) * 2).astype(np.float32)
+        vp, bp = d / "v.gguf", d / "b.gguf"
+        for p, f in ((vp, vf), (bp, bf)):
+            w = GGUFWriter(str(p), "llama", use_temp_file=False)
+            w.add_tensor("output.weight", quantize(f, Q.Q8_0), raw_dtype=Q.Q8_0)
+            w.write_header_to_file()
+            w.write_kv_data_to_file()
+            w.write_tensors_to_file()
+            w.close()
+        old_chunk = voice._DELTA_CHUNK_ELEMS
+        voice._DELTA_CHUNK_ELEMS = 100  # small and unaligned vs Q8_0 block 32
+        max_slice = []
+        orig_slice = voice._gguf_raw_slice_to_f32
+        def _spy(raw, qt, off, n):
+            max_slice.append(n)
+            return orig_slice(raw, qt, off, n)
+        voice._gguf_raw_slice_to_f32 = _spy
+        try:
+            out = voice._compute_delta(str(vp), str(bp), d / "out", "delta-x", ns())
+        finally:
+            voice._DELTA_CHUNK_ELEMS = old_chunk
+            voice._gguf_raw_slice_to_f32 = orig_slice
+        self.assertGreater(len(max_slice), 2, "expected many bounded chunks")
+        self.assertLessEqual(max(max_slice), 100, max_slice[:5])
+        vsrc, bsrc = voice.open_source(str(vp)), voice.open_source(str(bp))
+        want = (vsrc.read_f32("output.weight").astype(np.float32)
+                - bsrc.read_f32("output.weight").astype(np.float32)).astype("float16")
+        got = read_arr(out, "output.weight")
+        self.assertTrue((got == want).all())
+    def test_share_safe_delta_header(self):
+        import json as _j
+        d = Path(tempfile.mkdtemp())
+        home = d / "Users" / "someone" / "Desktop"
+        home.mkdir(parents=True)
+        self._pair(home)
+        out = voice._compute_delta(str(home / "v.safetensors"),
+                                   str(home / "b.safetensors"),
+                                   d / "out", "delta-x", ns())
+        outp = Path(str(out))
+        data = (outp / "voice.safetensors").read_bytes() \
+            if outp.is_dir() else outp.read_bytes()
+        hs = struct.unpack("<Q", data[:8])[0]
+        meta = _j.loads(data[8:8 + hs]).get("__metadata__", {})
+        blob = _j.dumps(meta)
+        self.assertNotIn("Users", blob)
+        self.assertNotIn("someone", blob)
+        self.assertEqual(meta.get("base"), "b.safetensors")
+        self.assertEqual(meta.get("voice"), "v.safetensors")
+
+    def test_verify_agrees(self):
+        d = Path(tempfile.mkdtemp())
+        write_st(d / "v.safetensors",
+                 {"output.weight": (np.zeros((4, 4), dtype=np.float16), "F16")})
+        meta = {"tensor_name": "output.weight", "shape": [4, 4],
+                "dtype": "F16", "type": "voice"}
+        self.assertEqual(voice._verify_voice_file(str(d / "v.safetensors"), meta), [])
+
+    def test_verify_flags_mismatch(self):
+        d = Path(tempfile.mkdtemp())
+        write_st(d / "v.safetensors",
+                 {"output.weight": (np.zeros((4, 4), dtype=np.float16), "F16")})
+        meta = {"tensor_name": "output.weight", "shape": [262144, 2048],
+                "dtype": "BF16", "type": "voice"}
+        warns = voice._verify_voice_file(str(d / "v.safetensors"), meta)
+        blob = "\n".join(warns)
+        self.assertIn("MISMATCH shape", blob)
+        self.assertIn("MISMATCH dtype", blob)
+        self.assertIn("file wins", blob)
+
+    def test_gguf_slice_q4k_superblocks(self):
+        # K-quants share scales across 256-elem superblocks: slices crossing
+        # superblock boundaries must equal full dequantize cut to the same range.
+        # (gguf lib can't quantize Q4_K here, so synthesize raw superblock bytes.)
+        from gguf.constants import GGMLQuantizationType as Q
+        from gguf.quants import dequantize
+        import numpy as _np
+        elems, bs, ts = 1024, 256, 144
+        raw = _np.random.default_rng(3).integers(0, 256, size=elems // bs * ts).astype(_np.uint8).tobytes()
+        full = dequantize(_np.frombuffer(raw, dtype=_np.uint8).reshape(-1, ts), Q.Q4_K).reshape(-1)
+        for off, n in ((0, 100), (200, 100), (100, 500), (900, 124), (0, 1024)):
+            b0 = off // bs
+            b1 = (off + n + bs - 1) // bs
+            seg = raw[b0 * ts:b1 * ts]
+            got = voice._gguf_raw_slice_to_f32(seg, Q.Q4_K, off - b0 * bs, n)
+            self.assertTrue((got == full[off:off + n]).all(), f"off={off} n={n}")
 
     def test_niche_gates_fail_fast_non_interactive(self):
         for mv, mb in ((False, True), (True, False), (True, True)):
@@ -353,6 +530,160 @@ class TestQuantShapes(unittest.TestCase):
 
 
 
+class TestVoicePacks(IsolatedVoices):
+    def _pack_pair(self, d):
+        write_st(d / "v.safetensors", {
+            "output.weight": (np.full((4, 4), 3.0, np.float16), "F16"),
+            "model.norm.weight": (np.full((8,), 5.0, np.float16), "F16")})
+        write_st(d / "b.safetensors", {
+            "output.weight": (np.full((4, 4), 2.0, np.float16), "F16"),
+            "model.norm.weight": (np.full((8,), 4.0, np.float16), "F16"),
+            "extra.weight": (np.zeros((2, 2), np.float16), "F16")})
+        return d / "v.safetensors", d / "b.safetensors"
+
+    def test_pack_delta_computes_all(self):
+        d = Path(tempfile.mkdtemp())
+        v, b = self._pack_pair(d)
+        out = voice._compute_delta(str(v), str(b), d / "out", "delta-x", ns())
+        for name, want in (("output.weight", 1.0), ("model.norm.weight", 1.0)):
+            got = read_arr(out, name)
+            self.assertTrue((got == want).all(), name)
+
+    def test_pack_delta_missing_name_fails(self):
+        d = Path(tempfile.mkdtemp())
+        write_st(d / "v.safetensors",
+                 {"ghost.weight": (np.zeros((2, 2), np.float16), "F16")})
+        write_st(d / "b.safetensors",
+                 {"other.weight": (np.zeros((2, 2), np.float16), "F16")})
+        with self.assertRaises(SystemExit):
+            voice._compute_delta(str(d / "v.safetensors"), str(d / "b.safetensors"),
+                                 d / "out", "delta-x", ns())
+
+    def test_tensor_cast_delta_fuses_not_replaces(self):
+        from gguf import GGUFReader, GGUFWriter
+        from gguf.constants import GGMLQuantizationType as Q
+        d = Path(tempfile.mkdtemp())
+        write_st(d / "v.safetensors",
+                 {"output.weight": (np.full((4, 4), 3.0, np.float16), "F16")})
+        write_st(d / "b.safetensors",
+                 {"output.weight": (np.full((4, 4), 2.0, np.float16), "F16")})
+        dout = voice._compute_delta(str(d / "v.safetensors"), str(d / "b.safetensors"),
+                                    d / "dout", "delta-x", ns())
+        tp = d / "t.gguf"
+        w = GGUFWriter(str(tp), "llama", use_temp_file=False)
+        w.add_architecture()
+        w.add_tensor("output.weight", np.full((4, 4), 10.0, np.float16), raw_dtype=Q.F16)
+        w.write_header_to_file()
+        w.write_kv_data_to_file()
+        w.write_tensors_to_file()
+        w.close()
+        out = d / "voiced.gguf"
+        voice.cmd_cast(ns(target=str(tp), voice=str(dout), out=str(out)))
+        got = [t for t in GGUFReader(str(out)).tensors if t.name == "output.weight"][0]
+        # base 10 + delta (3-2) = 11. Raw-delta replace would give 1.
+        self.assertTrue((np.asarray(got.data, dtype=np.float32) == 11.0).all())
+
+    def test_pack_cast_gguf_fuses_all(self):
+        from gguf import GGUFReader, GGUFWriter
+        from gguf.constants import GGMLQuantizationType as Q
+        d = Path(tempfile.mkdtemp())
+        v, b = self._pack_pair(d)
+        dout = voice._compute_delta(str(v), str(b), d / "dout", "delta-x", ns())
+        tp = d / "t.gguf"
+        w = GGUFWriter(str(tp), "llama", use_temp_file=False)
+        w.add_architecture()
+        w.add_tensor("output.weight", np.full((4, 4), 10.0, np.float16), raw_dtype=Q.F16)
+        w.add_tensor("model.norm.weight", np.full((8,), 20.0, np.float32), raw_dtype=Q.F32)
+        w.write_header_to_file()
+        w.write_kv_data_to_file()
+        w.write_tensors_to_file()
+        w.close()
+        out = d / "voiced.gguf"
+        voice.cmd_cast(ns(target=str(tp), voice=str(dout), out=str(out)))
+        back = {t.name: t for t in GGUFReader(str(out)).tensors}
+        self.assertTrue((np.asarray(back["output.weight"].data, dtype=np.float32) == 11.0).all())
+        self.assertTrue((np.asarray(back["model.norm.weight"].data, dtype=np.float32) == 21.0).all())
+
+    def test_pack_cast_safetensors_fuses_all(self):
+
+        d = Path(tempfile.mkdtemp())
+        v, b = self._pack_pair(d)
+        dout = voice._compute_delta(str(v), str(b), d / "dout", "delta-x", ns())
+        write_st(d / "t.safetensors", {
+            "output.weight": (np.full((4, 4), 10.0, np.float16), "F16"),
+            "model.norm.weight": (np.full((8,), 20.0, np.float16), "F16")})
+        out = d / "o.safetensors"
+        voice.cmd_cast(ns(target=str(d / "t.safetensors"),
+                          voice=str(dout), out=str(out)))
+        for name, want in (("output.weight", 11.0), ("model.norm.weight", 21.0)):
+            got = read_arr(out, name)
+            self.assertTrue((got == want).all(), name)
+
+    def test_pack_cast_safetensors_single_pass(self):
+        # The old chain called rewrite_safetensors_tensor once per tensor
+        # (O(N.file) full copies). The fused path must succeed with it disabled.
+        d = Path(tempfile.mkdtemp())
+        v, b = self._pack_pair(d)
+        dout = voice._compute_delta(str(v), str(b), d / "dout", "delta-x", ns())
+        write_st(d / "t.safetensors", {
+            "output.weight": (np.full((4, 4), 10.0, np.float16), "F16"),
+            "model.norm.weight": (np.full((8,), 20.0, np.float16), "F16")})
+        out = d / "o.safetensors"
+        orig = voice.rewrite_safetensors_tensor
+        def _boom(*a, **k):
+            raise AssertionError("chained per-tensor rewrite used")
+        voice.rewrite_safetensors_tensor = _boom
+        try:
+            voice.cmd_cast(ns(target=str(d / "t.safetensors"),
+                              voice=str(dout), out=str(out)))
+        finally:
+            voice.rewrite_safetensors_tensor = orig
+        for name, want in (("output.weight", 11.0), ("model.norm.weight", 21.0)):
+            got = read_arr(out, name)
+            self.assertTrue((got == want).all(), name)
+
+
+class TestBaseCache(unittest.TestCase):
+    def _cache(self, d, tensors):
+        write_st(d / "base.safetensors", tensors)
+        return d / "base.safetensors"
+
+    def test_validate_hit(self):
+        d = Path(tempfile.mkdtemp())
+        p = self._cache(d, {"a": (np.zeros((4, 4), np.float16), "F16")})
+        self.assertEqual(voice._cache_validate(str(p), ["a"]), [])
+
+    def test_validate_missing_and_truncated(self):
+        import struct as _st, json as _j
+        d = Path(tempfile.mkdtemp())
+        p = self._cache(d, {"a": (np.zeros((4, 4), np.float16), "F16")})
+        raw = bytearray(p.read_bytes())
+        hs = _st.unpack("<Q", bytes(raw[:8]))[0]
+        hdr = _j.loads(bytes(raw[8:8 + hs]))
+        hdr["b"] = {"dtype": "F16", "shape": [8], "data_offsets": [32, 48]}
+        hj = _j.dumps(hdr).encode()
+        p.write_bytes(_st.pack("<Q", len(hj)) + hj + bytes(raw[8 + hs:]))
+        self.assertEqual(sorted(voice._cache_validate(str(p), ["a", "b", "c"])), ["b", "c"])
+
+    def test_validate_garbage(self):
+        d = Path(tempfile.mkdtemp())
+        p = d / "base.safetensors"
+        p.write_bytes(b"not-a-safetensors-file")
+        self.assertEqual(voice._cache_validate(str(p), ["a"]), ["a"])
+
+    def test_topup_write_roundtrip(self):
+        d = Path(tempfile.mkdtemp())
+        p = self._cache(d, {"a": (np.full((4, 4), 7.0, np.float16), "F16")})
+        rawf = d / "raw.bin"
+        rawf.write_bytes(np.full((8,), 9.0, np.float16).tobytes())
+        staged = [("b", np.full((2, 2), 3.0, np.float16).tobytes(), "F16", (2, 2), None),
+                  ("c", None, "F16", (8,), rawf)]
+        new_hdr = voice._cache_topup_write(p, staged)
+        self.assertEqual(sorted(k for k in new_hdr if k != "__metadata__"), ["a", "b", "c"])
+        for name, want in (("a", 7.0), ("b", 3.0), ("c", 9.0)):
+            self.assertTrue((read_arr(p, name) == want).all(), name)
+
+
 class TestRunGuarded(unittest.TestCase):
     def test_timeout_reaps_child(self):
         import subprocess
@@ -382,5 +713,380 @@ class TestRunGuarded(unittest.TestCase):
         r = run_guarded(["echo", "hi"], timeout=30)
         self.assertEqual((r.returncode, r.stdout.strip()), (0, "hi"))
 
+class TestAliases(unittest.TestCase):
+    GGUF_NAMES = ["token_embd.weight", "blk.28.attn_o.weight", "blk.29.attn_o.weight",
+                  "blk.29.ffn_down.weight", "output_norm.weight", "output.weight"]
+
+    def test_alias_both_directions(self):
+        self.assertEqual(voice._pack_aliases("model.language_model.embed_tokens.weight", self.GGUF_NAMES),
+                         ["token_embd.weight"])
+        self.assertEqual(voice._pack_aliases("token_embd.weight",
+                         ["model.language_model.embed_tokens.weight", "output.weight"]),
+                         ["model.language_model.embed_tokens.weight"])
+        self.assertEqual(voice._pack_aliases("model.language_model.layers.29.self_attn.o_proj.weight",
+                                             self.GGUF_NAMES),
+                         ["blk.29.attn_o.weight"])
+        self.assertEqual(voice._pack_aliases("lm_head.weight", self.GGUF_NAMES), ["output.weight"])
+
+    def test_alias_block_mismatch_is_no_match(self):
+        self.assertEqual(voice._pack_aliases("model.language_model.layers.28.self_attn.o_proj.weight",
+                                             ["blk.29.attn_o.weight"]), [])
+        self.assertEqual(voice._pack_aliases("someday.weight", self.GGUF_NAMES), [])
+
+    def test_alias_ambiguous_lists_all(self):
+        self.assertEqual(sorted(voice._pack_aliases("model.embed_tokens.weight",
+                                                    ["a.token_embd.weight", "b.token_embd.weight"])),
+                         ["a.token_embd.weight", "b.token_embd.weight"])
+
+    def test_alias_modern_gguf_variants(self):
+        # Evidenced live: Gemma3/Qwen3 GGUFs use attn_output + post_attention_norm.
+        names = ["blk.29.attn_output.weight", "blk.29.post_attention_norm.weight"]
+        self.assertEqual(voice._pack_aliases("model.layers.29.self_attn.o_proj.weight", names),
+                         ["blk.29.attn_output.weight"])
+        self.assertEqual(voice._pack_aliases("model.layers.29.post_attention_layernorm.weight", names),
+                         ["blk.29.post_attention_norm.weight"])
+
+    def test_alias_glm_generations(self):
+        # Evidenced live: ChatGLM-style HF names vs llama.cpp GGUF names.
+        gguf = ["token_embd.weight", "blk.39.attn_output.weight",
+                "blk.39.ffn_down.weight", "output_norm.weight", "output.weight"]
+        self.assertEqual(voice._pack_aliases("transformer.encoder.layers.39.self_attention.dense.weight", gguf),
+                         ["blk.39.attn_output.weight"])
+        self.assertEqual(voice._pack_aliases("transformer.encoder.layers.39.mlp.dense_4h_to_h.weight", gguf),
+                         ["blk.39.ffn_down.weight"])
+        self.assertEqual(voice._pack_aliases("transformer.encoder.final_layernorm.weight", gguf),
+                         ["output_norm.weight"])
+        self.assertEqual(voice._pack_aliases("transformer.output_layer.weight", gguf),
+                         ["output.weight"])
+
+    def test_pack_preset_head_only(self):
+        # Preset is the output head, nothing else. Tied repos resolve the embed
+        # (it doubles as head); untied resolve lm_head.
+        d = Path(tempfile.mkdtemp())
+        write_st(d / "tied.safetensors", {
+            "model.language_model.embed_tokens.weight": (np.zeros((8, 4), np.float16), "F16"),
+            "model.language_model.norm.weight": (np.zeros((4,), np.float16), "F16")})
+        write_st(d / "untied.safetensors", {
+            "lm_head.weight": (np.zeros((8, 4), np.float16), "F16"),
+            "model.embed_tokens.weight": (np.zeros((8, 4), np.float16), "F16"),
+            "model.norm.weight": (np.zeros((4,), np.float16), "F16")})
+        src = voice.open_source(str(d / "tied.safetensors"))
+        self.assertEqual(_resolve_pack_tensors(src, "r", None, src.names()),
+                         ["model.language_model.embed_tokens.weight"])
+        src = voice.open_source(str(d / "untied.safetensors"))
+        self.assertEqual(_resolve_pack_tensors(src, "r", None, src.names()),
+                         ["lm_head.weight"])
+
+    def test_alias_moe_experts(self):
+        # Evidenced live: Qwen3-30B-A3B GGUF experts vs HF experts.* names.
+        gguf = ["blk.5.ffn_down_exps.weight", "blk.5.ffn_gate_inp.weight"]
+        self.assertEqual(voice._pack_aliases("model.layers.5.experts.down_proj", gguf),
+                         ["blk.5.ffn_down_exps.weight"])
+        # fused HF gate_up has no 1:1 GGUF counterpart (split exps) — no match, fail loud downstream
+        self.assertEqual(voice._pack_aliases("model.layers.5.experts.gate_up_proj", gguf), [])
+        # routers never map (semantics differ per arch)
+        self.assertEqual(voice._pack_aliases("model.layers.5.router.per_expert_scale", gguf), [])
+
+    def test_pack_cast_bridges_naming(self):
+        # ST pack names onto a GGUF target speaking llama.cpp names (replace mode).
+        from gguf import GGUFReader, GGUFWriter
+        from gguf.constants import GGMLQuantizationType as Q
+        d = Path(tempfile.mkdtemp())
+        write_st(d / "pack.safetensors", {
+            "model.language_model.embed_tokens.weight": (np.full((4, 4), 3.0, np.float16), "F16"),
+            "lm_head.weight": (np.full((4, 4), 7.0, np.float16), "F16")})
+        tp = d / "t.gguf"
+        w = GGUFWriter(str(tp), "llama", use_temp_file=False)
+        w.add_architecture()
+        w.add_tensor("token_embd.weight", np.zeros((4, 4), dtype=np.float16), raw_dtype=Q.F16)
+        w.add_tensor("output.weight", np.zeros((4, 4), dtype=np.float16), raw_dtype=Q.F16)
+        w.write_header_to_file()
+        w.write_kv_data_to_file()
+        w.write_tensors_to_file()
+        w.close()
+        out = d / "voiced.gguf"
+        voice.cmd_cast(ns(target=str(tp), voice=str(d / "pack.safetensors"), out=str(out)))
+        back = {t.name: np.asarray(t.data, dtype=np.float32) for t in GGUFReader(str(out)).tensors}
+        self.assertTrue((back["token_embd.weight"] == 3.0).all())
+        self.assertTrue((back["output.weight"] == 7.0).all())
+
+
+    def test_nearest_encodable_mapping(self):
+        from gguf.constants import GGMLQuantizationType as Q
+        self.assertEqual(voice._nearest_encodable(Q.IQ4_NL), Q.Q4_0)  # same 4.5bpp
+        self.assertEqual(voice._nearest_encodable(Q.Q4_K), Q.Q4_0)
+        self.assertEqual(voice._nearest_encodable(Q.Q6_K), Q.Q5_1)
+
+    def test_unencodable_target_keeps_nearest(self):
+        # Q4_K target (decode-only in gguf lib): fused output lands on Q4_0, not F16.
+        from gguf import GGUFReader, GGUFWriter
+        from gguf.constants import GGMLQuantizationType as Q
+        from gguf.quants import quant_shape_to_byte_shape
+        d = Path(tempfile.mkdtemp())
+        logical = (256, 256)
+        raw = np.zeros(quant_shape_to_byte_shape(logical, Q.Q4_K), dtype=np.uint8)
+        tp = d / "t.gguf"
+        w = GGUFWriter(str(tp), "llama", use_temp_file=False)
+        w.add_architecture()
+        w.add_tensor("blk.0.ffn_down.weight", raw, raw_dtype=Q.Q4_K)
+        w.write_header_to_file()
+        w.write_kv_data_to_file()
+        w.write_tensors_to_file()
+        w.close()
+        got = [t for t in GGUFReader(str(tp)).tensors if t.name == "blk.0.ffn_down.weight"][0]
+        self.assertEqual(got.tensor_type, Q.Q4_K)
+        write_st(d / "v.safetensors",
+                 {"blk.0.ffn_down.weight": (np.full(logical, 1.0, np.float16), "F16")})
+        write_st(d / "b.safetensors",
+                 {"blk.0.ffn_down.weight": (np.zeros(logical, np.float16), "F16")})
+        dout = voice._compute_delta(str(d / "v.safetensors"), str(d / "b.safetensors"),
+                                    d / "dout", "delta-x", ns())
+        out = d / "voiced.gguf"
+        voice.cmd_cast(ns(target=str(tp), voice=str(dout), out=str(out)))
+        fused = [t for t in GGUFReader(str(out)).tensors if t.name == "blk.0.ffn_down.weight"][0]
+        self.assertEqual(fused.tensor_type, Q.Q4_0)
+
+
+    def test_batch_miss_reports_all_with_hints(self):
+        # One failure names EVERY miss (no fix-forward) with same-size hints.
+        import io
+        from contextlib import redirect_stdout
+        names = ["token_embd.weight", "blk.29.attn_o.weight", "other.weight"]
+        counts = {"token_embd.weight": 16, "blk.29.attn_o.weight": 16, "other.weight": 64}
+        pairs = [("model.language_model.layers.29.self_attn.o_proj.weight", (4, 4)),
+                 ("ghost.weight", (8, 8)),
+                 ("phantom.weight", (2, 2))]
+        buf = io.StringIO()
+        with redirect_stdout(buf):
+            with self.assertRaises(SystemExit):
+                voice._resolve_pack_targets(pairs, names, "t.gguf", counts)
+        blob = buf.getvalue()
+        self.assertIn("ghost.weight", blob)
+        self.assertIn("phantom.weight", blob)
+        self.assertIn("other.weight", blob)  # same-size hint for the 8x8 ghost
+        self.assertIn("2 tensor(s)", blob)  # both misses at once; the aliased one is not listed
+        # all-resolvable returns the mapping (exact + alias)
+        got = voice._resolve_pack_targets(
+            [("model.language_model.layers.29.self_attn.o_proj.weight", (4, 4)),
+             ("token_embd.weight", (4, 4))],
+            names, "t.gguf", counts)
+        self.assertEqual(got, {"model.language_model.layers.29.self_attn.o_proj.weight": "blk.29.attn_o.weight",
+                               "token_embd.weight": "token_embd.weight"})
+
+    def test_pack_cast_bridges_same_format_prefix(self):
+        # Qwen-style prefixed voice onto bare names: same (block, trailing
+        # role) + equal count maps without growing _ROLE_ALIASES.
+        import io
+        from contextlib import redirect_stdout
+        got = voice._resolve_pack_targets(
+            [("model.language_model.layers.29.self_attn.o_proj.weight", (4, 4))],
+            ["model.layers.29.self_attn.o_proj.weight"], "t.safetensors",
+            {"model.layers.29.self_attn.o_proj.weight": 16})
+        self.assertEqual(got, {"model.language_model.layers.29.self_attn.o_proj.weight":
+                               "model.layers.29.self_attn.o_proj.weight"})
+        # …but a count mismatch stays loud, not a silent wrong-slot write.
+        buf = io.StringIO()
+        with redirect_stdout(buf):
+            with self.assertRaises(SystemExit):
+                voice._resolve_pack_targets(
+                    [("model.language_model.layers.29.self_attn.o_proj.weight", (4, 8))],
+                    ["model.layers.29.self_attn.o_proj.weight"], "t.safetensors",
+                    {"model.layers.29.self_attn.o_proj.weight": 16})
+        self.assertIn("not found", buf.getvalue())
+
+class TestEntry(IsolatedVoices):
+    """Launch-path proofs: the P3 split moved commands into vlib/, so entry
+    identity (__main__) must be resolved explicitly, never via __file__."""
+
+    def test_entry_script_resolves_main(self):
+        import types
+        fake = types.SimpleNamespace(__file__="voice.py")
+        old = sys.modules.get("__main__")
+        sys.modules["__main__"] = fake
+        try:
+            got = voice._entry_script()
+        finally:
+            if old is not None:
+                sys.modules["__main__"] = old
+        self.assertTrue(os.path.isabs(got), got)
+        self.assertTrue(got.endswith("voice.py"), got)
+
+    def test_entry_script_unknown_is_none(self):
+        import types
+        old = sys.modules.get("__main__")
+        sys.modules["__main__"] = types.SimpleNamespace()
+        try:
+            self.assertIsNone(voice._entry_script())
+        finally:
+            if old is not None:
+                sys.modules["__main__"] = old
+
+    def test_venv_reexec_targets_entry(self):
+        # Re-exec must run voice.py (absolute) with argv intact — never the module.
+        import types
+        d = Path(tempfile.mkdtemp())
+        vp = d / ".venv" / "bin"
+        vp.mkdir(parents=True)
+        (vp / "python").symlink_to(sys.executable)
+        from vlib import ctx
+        old_dir, old_main, old_argv = ctx.VOICES_DIR, sys.modules.get("__main__"), sys.argv[:]
+        old_venv = os.environ.pop("VOICE_NO_VENV", None)
+        ctx.VOICES_DIR = d
+        sys.modules["__main__"] = types.SimpleNamespace(__file__="voice.py")
+        sys.argv = ["voice.py", "delta", "x"]
+        captured = {}
+        orig_execv = os.execv
+
+        class _Stop(BaseException):
+            pass
+
+        os.execv = lambda p, a: captured.update(path=p, argv=a) or (_ for _ in ()).throw(_Stop())
+        try:
+            with self.assertRaises(_Stop):
+                voice._ensure_venv("delta")
+        finally:
+            os.execv = orig_execv
+            ctx.VOICES_DIR = old_dir
+            if old_main is not None:
+                sys.modules["__main__"] = old_main
+            sys.argv = old_argv
+            if old_venv is not None:
+                os.environ["VOICE_NO_VENV"] = old_venv
+        self.assertTrue(captured["argv"][1].endswith("/voice.py"), captured["argv"])
+        self.assertNotIn("cmds_misc", captured["argv"][1])
+        self.assertEqual(captured["argv"][2:], ["delta", "x"])
+
+    def test_entry_help_runs_main(self):
+        # The suite calls cmd_* directly and never executes main()'s parser
+        # wiring — a deleted flag or bad indent kills every real invocation
+        # while the suite stays green. This pins the entry path end to end.
+        import subprocess
+        root = Path(__file__).resolve().parent.parent
+        env = dict(os.environ, VOICE_NO_VENV="1")
+        outs = []
+        for argv in (["--help"], ["cast", "--help"], ["list"]):
+            r = subprocess.run([sys.executable, str(root / "voice.py"), *argv],
+                               capture_output=True, text=True, timeout=120, env=env)
+            self.assertEqual(r.returncode, 0, (argv, r.stderr[-500:]))
+            outs.append(r.stdout)
+        self.assertIn("{get,cast,delta,add,list,info,remove,cleanup,auth,report,path,doctor}", outs[0])
+        self.assertIn("--speak", outs[1])
+
+    def test_voice_tensors_coerces_bare_strings(self):
+        # Hand-written voice.json may list tensors as bare strings; readers
+        # must render them, never traceback (P1 crash: only.get on a str).
+        got, synth = voice._voice_tensors({"tensors": ["lm_head.weight"]})
+        self.assertEqual(got, [{"name": "lm_head.weight"}])
+        self.assertFalse(synth)
+
+    def test_quant_override_byte_change_fails_fast(self):
+        # --quant f16 on an F32 safetensors target can never fit the fixed
+        # offsets: fail up front with guidance, not warn-then-dump (B1).
+        import io
+        from contextlib import redirect_stdout
+        d = Path(tempfile.mkdtemp())
+        write_st(d / "t.safetensors",
+                 {"output.weight": (np.zeros((4, 4), np.float32), "F32")})
+        write_st(d / "v.safetensors",
+                 {"output.weight": (np.zeros((4, 4), np.float32), "F32")})
+        header, tensors = voice.read_safetensors(str(d / "t.safetensors"))
+        src = voice.open_source(str(d / "v.safetensors"))
+        ref = src.ref("output.weight")
+        buf = io.StringIO()
+        with redirect_stdout(buf):
+            with self.assertRaises(SystemExit):
+                voice._cast_st_prepare(str(d / "t.safetensors"), tensors,
+                                       src.read_f32("output.weight"), ref, {},
+                                       ns(quant="f16"))
+        self.assertIn("different byte size", buf.getvalue())
+
+    def test_cancel_exits_nonzero(self):
+        # Abandoned prompts (EOF/decline) must exit nonzero so scripts can
+        # tell cancel from success (B2 contract).
+        from unittest import mock
+        from vlib.ui import _confirm
+        with mock.patch("builtins.input", side_effect=EOFError), \
+             mock.patch.object(sys.stdin, "isatty", return_value=True):
+            with self.assertRaises(SystemExit) as cm:
+                _confirm("  Overwrite? [y/N]: ",
+                         ns(non_interactive=False, yes=False))
+        self.assertNotEqual(cm.exception.code, 0)
+
+    def test_requested_subset_routes_by_role(self):
+        # An explicitly named tensor must land in its own slot, never the
+        # output-first fallback (D2: embed request fitted onto lm_head).
+        d = Path(tempfile.mkdtemp())
+        write_st(d / "v.safetensors", {
+            "model.embed_tokens.weight": (np.full((4, 3), 7.0, np.float16), "F16"),
+            "model.lm_head.weight": (np.full((8, 4), 8.0, np.float16), "F16")})
+        write_st(d / "t.safetensors", {
+            "model.embed_tokens.weight": (np.full((4, 3), 1.0, np.float16), "F16"),
+            "model.lm_head.weight": (np.full((8, 4), 2.0, np.float16), "F16")})
+        out = d / "o.safetensors"
+        voice.cmd_cast(ns(target=str(d / "t.safetensors"), voice=str(d / "v.safetensors"),
+                           out=str(out), tensors=["model.embed_tokens.weight"]))
+        self.assertTrue((read_arr(out, "model.embed_tokens.weight", np.float16) == 7.0).all())
+        self.assertTrue((read_arr(out, "model.lm_head.weight", np.float16) == 2.0).all())
+
+
+class TestSymlinkHardening(IsolatedVoices):
+    """Proof tests for the P3 symlink hardening (local CLI, self-owned dir)."""
+
+    def test_unresolvable_path_fails_closed(self):
+        # Old code swallowed resolve errors and returned (fail-open).
+        with self.assertRaises(SystemExit):
+            voice._assert_not_symlink("/tmp/voices-probe\x00evil")
+
+    def test_relative_path_under_symlinked_subdir_rejected(self):
+        # Old code compared raw strings, so a cwd-relative in-registry path
+        # never matched the absolute VOICES_DIR scope and skipped the walk.
+        import os as _os
+        t = Path(tempfile.mkdtemp())
+        (t / "real" / ".voices").mkdir(parents=True)
+        (t / "elsewhere").mkdir()
+        try:
+            (t / "real" / ".voices" / "sub").symlink_to(t / "elsewhere")
+        except OSError:
+            self.skipTest("symlinks unsupported here")
+        ctx_mod = sys.modules["vlib.ctx"]
+        old, old_ctx = voice.VOICES_DIR, ctx_mod.VOICES_DIR
+        prev_cwd = _os.getcwd()
+        try:
+            voice.VOICES_DIR = t / "real" / ".voices"
+            ctx_mod.VOICES_DIR = t / "real" / ".voices"
+            _os.chdir(t)
+            with self.assertRaises(SystemExit):
+                voice._assert_not_symlink("real/.voices/sub/evil")
+        finally:
+            _os.chdir(prev_cwd)
+            voice.VOICES_DIR = old
+            ctx_mod.VOICES_DIR = old_ctx
+
+    def test_scope_boundaries(self):
+        # Legit nested registry path: silent. Prefix-adjacent sibling
+        # (".voices2"-style, outside but string-matching): refused, as before.
+        # Genuinely unrelated user path: untouched.
+        (self.vdir / "myadd").mkdir()
+        voice._assert_not_symlink(self.vdir / "myadd" / "voice.json")
+        sib = self.vdir.parent / (self.vdir.name + "2")
+        sib.mkdir(exist_ok=True)
+        with self.assertRaises(SystemExit):
+            voice._assert_not_symlink(sib / "voice.json")
+        voice._assert_not_symlink(Path(tempfile.mkdtemp()) / "voice.json")
+
+    def test_topup_write_refuses_symlink(self):
+        d = Path(tempfile.mkdtemp())
+        hdr = {"a": {"dtype": "F16", "shape": [4], "data_offsets": [0, 8]}}
+        hj = json.dumps(hdr).encode()
+        real = d / "base.safetensors"
+        real.write_bytes(struct.pack("<Q", len(hj)) + hj + b"\x00" * 8)
+        link = d / "link.safetensors"
+        try:
+            link.symlink_to(real)
+        except OSError:
+            self.skipTest("symlinks unsupported here")
+        with self.assertRaises(SystemExit):
+            voice._cache_topup_write(link, [])
+
 if __name__ == "__main__":
     unittest.main()

vlib/cache.py

@@ -5,11 +5,12 @@ import json
 import os
 import struct
 from vlib import ctx
-from vlib.ui import _fail, _now_iso, _step, _warn
+from vlib.ui import _fail, _now_iso, _say, _step, _warn
 from vlib.net import _cleanup_tmp, _safe_id, http_get_json
 from vlib.tensors import _is_ggml_quant, _write_safetensors_streaming, read_safetensors, write_safetensors
 from vlib.sources import _base_paths, open_source
 from vlib.fetch import _fetch_tensor, _resolve_output_name, _source_arch
+from vlib.delta import _tied_embed_name, _voice_head_name
 from vlib.registry import _assert_not_symlink
 
 
@@ -118,6 +119,32 @@ def _cache_topup_write(base_file, staged):
     return new_hdr
 
 
+def _tied_head_want(base_id, rev, want):
+    """Reroute a wanted voice head onto the base's tied embed tensor.
+    Voice untied + base tied: the base can never serve the head name, so
+    want the embed instead (the delta pairs them later). Returns the
+    want list, order-preserved and deduplicated. Anything unresolvable
+    (offline, base has the head, base not tied) returns want unchanged
+    and downstream fails exactly as before."""
+    head = _voice_head_name(want)
+    if head is None or head not in want:
+        return want
+    try:
+        src = open_source(base_id, rev=rev)
+        names = [n for n in src.names() if n != "delta.voice.marker"]
+    except SystemExit:
+        raise
+    except Exception:
+        return want
+    if head in names:
+        return want
+    emb = _tied_embed_name(names)
+    if emb is None:
+        return want
+    _say(f"  → Base head is tied; caching '{emb}' for the head delta.")
+    return list(dict.fromkeys(emb if n == head else n for n in want))
+
+
 def _ensure_base_tensors(base_id, names, args=None):
     """Base cache with per-tensor trust: top-ups what's missing, self-heals partial caches.
     All fetches pin one revision so a repo update mid-cache can't mix commits. Returns base_file."""
@@ -199,6 +226,7 @@ def _ensure_base_tensors_locked(base_id, base_file, base_json, want):
         elif not verified:
             _warn("  Base cache lineage unverified (offline?) — proceeding, mixed revisions possible.")
     rev = _base_rev(base_id, base_file)
+    want = _tied_head_want(base_id, rev, want)
     missing = _cache_validate(base_file, want)
     if not missing:
         return base_file

vlib/delta.py

@@ -9,11 +9,57 @@ import time
 from vlib.ui import _fail, _noninteractive, _progress_pref, _say, _transform, _warn
 from vlib.net import _fmt_eta
 from vlib.tensors import _is_delta_safetensors, _is_ggml_quant, decode_to_f32, dtype_bytes, read_safetensors
-from vlib.sources import _detect_base, _normalize_hf_repo, _public_source, open_source
+from vlib.sources import _detect_base, _normalize_hf_repo, _public_source, open_source, OUTPUT_ALIASES, EMBEDDING_ALIASES
 from vlib.fetch import _resolve_output_name, _source_arch
 from vlib.registry import _assert_not_symlink, _iter_voices, _read_meta
 
 
+_EMBED_SUFFIXES = ("embed_tokens.weight", "word_embeddings.weight", "wte.weight", "token_embd.weight")
+
+
+def _tied_embed_name(b_names):
+    """Base-side tied counterpart: the embed tensor doubling as output head.
+    Returns the embed name only when the base is truly headless (no head
+    tensor at all); otherwise None."""
+    for n in b_names:
+        if n in OUTPUT_ALIASES:
+            return None
+        if n.endswith("weight") and ("lm_head" in n or "output_layer" in n or "embed_out" in n):
+            return None
+    for n in b_names:
+        if n in EMBEDDING_ALIASES or n.endswith(_EMBED_SUFFIXES):
+            return n
+    return None
+
+
+def _voice_head_name(v_names):
+    """Voice-side output head: exact alias first, head-like pattern after."""
+    for n in v_names:
+        if n in OUTPUT_ALIASES:
+            return n
+    for n in v_names:
+        if n.endswith("weight") and ("lm_head" in n or "output_layer" in n or "embed_out" in n):
+            return n
+    return None
+
+
+def _tied_head_pair(head, b_names, vshape, bshape_of):
+    """Voice untied + base tied: pair the voice head with the base's tied
+    embed tensor (it serves as both input and output projection, so it is
+    the only valid counterpart). Returns the base name, or None when the
+    base is not tied. Shapes must match exactly."""
+    if head is None:
+        return None
+    b_emb = _tied_embed_name(b_names)
+    if b_emb is None:
+        return None
+    bshape = tuple(bshape_of(b_emb))
+    if tuple(vshape) != bshape:
+        _fail(f"  ✗ Voice head '{head}' {list(vshape)} doesn't fit tied base '{b_emb}' {list(bshape)} — layouts differ.")
+    _say(f"  → Base head is tied; '{head}' deltas against '{b_emb}'.")
+    return b_emb
+
+
 def _choose_voice(args):
     voices = []
     for d in _iter_voices():
@@ -162,10 +208,18 @@ def _compute_delta(voice_path, base_path, delta_folder, delta_name, args=None):
             _cand = None
         ordered = ([_cand] if _cand in v_names else []) + [n for n in v_names if n != _cand]
         missing = [n for n in ordered if n not in b_names]
+        fallback = {}
+        v_head = _voice_head_name(v_names)
+        if v_head in missing:
+            b = _tied_head_pair(v_head, b_names, tuple(v_src.ref(v_head).shape),
+                                lambda n: tuple(b_src.ref(n).shape))
+            if b is not None:
+                fallback[v_head] = b
+        missing = [n for n in missing if n not in fallback]
         if missing:
             shown = ", ".join(missing[:5]) + ("…" if len(missing) > 5 else "")
             _fail(f"  ✗ {len(missing)} voice tensor(s) have no match in base: {shown}. Delta needs same names on both sides.")
-        pairs = [(n, n) for n in ordered]
+        pairs = [(n, fallback.get(n, n)) for n in ordered]
         _check_delta_gate(args, voice_path, base_path)
         _assert_not_symlink(delta_folder)
         delta_folder.mkdir(parents=True, exist_ok=True)
@@ -247,10 +301,18 @@ def _compute_delta(voice_path, base_path, delta_folder, delta_name, args=None):
     if not v_keys:
         _fail("  ✗ No tensors found for delta.")
     missing = [k for k in v_keys if k not in b_tensors]
+    fallback = {}
+    v_head = _voice_head_name(v_keys)
+    if v_head in missing:
+        b = _tied_head_pair(v_head, list(b_tensors.keys()), tuple(v_tensors[v_head]["shape"]),
+                             lambda n: tuple(b_tensors[n]["shape"]))
+        if b is not None:
+            fallback[v_head] = b
+    missing = [k for k in missing if k not in fallback]
     if missing:
         shown = ", ".join(missing[:5]) + ("…" if len(missing) > 5 else "")
         _fail(f"  ✗ {len(missing)} voice tensor(s) have no match in base: {shown}. Delta needs same names on both sides.")
-    pairs = [(k, k) for k in v_keys]
+    pairs = [(k, fallback.get(k, k)) for k in v_keys]
     _check_delta_gate(args, voice_path, base_path)
     with open(voice_path, "rb") as f:
         v_hs = struct.unpack("<Q", f.read(8))[0]

voice-cli.tar.gz

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:6f57c560666c407c280e5880e644e08fd09b2d020b317888f41afced8dc88b9d
-size 69538
+oid sha256:8ebae7075d10181b2d6a5a640d8b064358dc3cbdac34a46f91444c00f01c2abf
+size 70556

voice.py

@@ -49,7 +49,7 @@ from vlib.tensors import _validate_safetensors_header, read_safetensors, write_s
 from vlib.sources import OUTPUT_ALIASES, EMBEDDING_ALIASES, _family, _nested, detect_output_tensor, largest_2d, _hf_config, _hf_license, _hf_model_index, _normalize_hf_repo, _base_paths, _hf_api_base_model, _hf_mergekit_base, _detect_base, TensorRef, SafetensorsSource, GgufSource, open_source, _source_from_repo, _pick_gguf, _sanitize_voice_name, _NAME_RULES, _public_source, _slugify_voice_name
 from vlib.fetch import _source_arch, _resolve_output_name, _stream_safetensors_tensor, _fetch_tensor, _stream_gguf_tensor, _fetch_pack, _write_fetched, _write_voicepack_json
 from vlib.registry import log_operation, _atomic_jsonl_append, _write_outbox, _append_report, _iter_voices, _registry_resolve, _read_meta, _registry_name_exists, _registry_folder, _assert_not_symlink, _write_voice, _resolve_name, _out_path, _stem, _check_overwrite
-from vlib.cache import _base_rev, _cache_validate, _cache_topup_write, _ensure_base_tensors, _ensure_base_tensors_locked, _cache_base, _load_safetensors_or_gguf_f32
+from vlib.cache import _base_rev, _cache_validate, _cache_topup_write, _ensure_base_tensors, _ensure_base_tensors_locked, _cache_base, _load_safetensors_or_gguf_f32, _tied_head_want
 from vlib.delta import _choose_voice, _resolve_base, _delta_gate, _check_delta_gate, _compute_delta
 from vlib.reports import _hash_file, _sanitize_note, _sanitize_reporter, _prompt_share, _push_reports_batch, _push_report, _last_operation, cmd_report
 from vlib.cmds_voices import cmd_get, cmd_cast, cmd_delta, cmd_add

voice.pyz

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:c40ffe00455ad5333d675583f91175f9ae059bce03fa2a8a64dc16837379981e
-size 256579
+oid sha256:7568525f51fe2bbebeec82b6dd709bb3fb62f798e52485c0cf63290a7f5e4cec
+size 260239