samvada 20261111.1__tar.gz

samvada-20261111.1/.gitignore

@@ -0,0 +1,13 @@
+__pycache__/
+*.egg-info/
+.venv/
+build/
+dist/
+.pytest_cache/
+*.wav
+*.mp3
+# voices, models and engines are downloaded, never committed (voices.lock pins them)
+*.onnx
+*.onnx.json
+g2pW/
+nltk_data/

samvada-20261111.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Cong Zhang
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

samvada-20261111.1/PKG-INFO

@@ -0,0 +1,101 @@
+Metadata-Version: 2.5
+Name: samvada
+Version: 20261111.1
+Summary: Samvada: a voice and the habits of a language tutor for AI agents, offline first
+Project-URL: Homepage, https://github.com/congzhangzh/samvada
+Project-URL: Source, https://github.com/congzhangzh/samvada
+Project-URL: Releases, https://github.com/congzhangzh/samvada/releases
+Author-email: Cong Zhang <13283869+congzhangzh@users.noreply.github.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: ai-agent,language-learning,offline,piper,text-to-speech,tts
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Multimedia :: Sound/Audio :: Speech
+Requires-Python: >=3.11
+Provides-Extra: online
+Requires-Dist: edge-tts>=7; extra == 'online'
+Description-Content-Type: text/markdown
+
+# Samvada
+
+**A voice for AI agents, offline first.** The agent decides what to say; Samvada decides
+whether, where and how it is heard. *Samvada* (संवाद, *saṃvāda*) means dialogue.
+
+- **Offline first.** Local voices (Piper) for English and Chinese, French and Japanese as
+  optional packs. Online voices (edge-tts) are **off by default**, so your text never leaves
+  the machine unless you turn them on.
+- **Plays only where you are.** Silent when the screen is locked, when you are muted, or when
+  your last input came from your phone instead of this desk. Silence is never an error.
+- **One call, every language.** The caller passes all its languages in order; Samvada skips
+  the ones that are off or have no voice installed.
+- **No dependencies.** The package itself is pure Python; each voice engine runs in its own
+  folder, with pinned versions.
+
+Status: alpha. Linux (GNOME) is the tested platform.
+
+## Install
+
+```bash
+uv tool install samvada          # or: pipx install samvada, pip install samvada
+samvada voices add en zh         # once: about 290 MB, downloaded and verified
+```
+
+## Use
+
+```bash
+samvada speak en "Hello" zh "你好"   # plays in this order, then exits
+samvada status                      # where the voice goes now, and why
+samvada mute "watching TV"          # silent until `samvada unmute`
+samvada lang off fr                 # skip a language (the caller still passes it)
+samvada --session mute              # the same, for this terminal session only
+samvada online fallback             # allow edge-tts for a language that fails offline
+                                    #   (needs: pip install 'samvada[online]')
+samvada presence phone              # a chat bridge says: the owner just wrote from the phone
+samvada voices verify               # check the installed voices against their checksums
+```
+
+Exit codes: `0` played, or silent by decision; `1` a language failed; `2` bad usage.
+
+## Voice packs
+
+Every file a pack needs is pinned in `src/samvada/voices.lock`: a commit on the
+[Hugging Face Hub](https://huggingface.co) (or a URL at a commit), with its size and sha256.
+`samvada voices add` downloads from the Hub's resolve URLs, resumes partial downloads, and
+checks every file before putting it in place. Nothing needs configuring; optionally
+`HF_ENDPOINT` points at a mirror and `HF_TOKEN` lifts anonymous rate limits.
+
+| Pack | Voice | Engine | Source |
+|---|---|---|---|
+| en | `en_US-lessac-high` | Piper | `rhasspy/piper-voices` |
+| zh | `zh_CN-xiao_ya-medium` + g2pW + BERT tokenizer | Piper | `rhasspy/piper-voices`, `rhasspy/piper-checkpoints`, `google-bert/bert-base-chinese` |
+| ja | Tsukuyomi-chan | piper-plus | `ayousanz/piper-plus-tsukuyomi-chan` + NLTK data |
+| fr | `fr_FR-siwis-medium` | Piper | `rhasspy/piper-voices` |
+
+Each voice keeps its own license; see its model card on the Hub before you redistribute it.
+
+## Where things live
+
+| What | Where |
+|---|---|
+| Settings (mute, languages, online mode, sessions) | `$XDG_STATE_HOME/samvada/` |
+| Voices, engines | `$XDG_DATA_HOME/samvada/{voices,engines}/` (or `$SAMVADA_VOICES`, `$SAMVADA_ENGINES`) |
+
+## Develop
+
+```bash
+uv run pytest -q                     # fake engines, player, desktop and Hub: no audio, no network
+uv run python release/bundle.py <version> --test   # the standalone bundle and its offline test
+```
+
+## License
+
+MIT, see [LICENSE](LICENSE). The voices are not part of this package; they are downloaded
+from their own repositories under their own licenses.

samvada-20261111.1/README.md

@@ -0,0 +1,75 @@
+# Samvada
+
+**A voice for AI agents, offline first.** The agent decides what to say; Samvada decides
+whether, where and how it is heard. *Samvada* (संवाद, *saṃvāda*) means dialogue.
+
+- **Offline first.** Local voices (Piper) for English and Chinese, French and Japanese as
+  optional packs. Online voices (edge-tts) are **off by default**, so your text never leaves
+  the machine unless you turn them on.
+- **Plays only where you are.** Silent when the screen is locked, when you are muted, or when
+  your last input came from your phone instead of this desk. Silence is never an error.
+- **One call, every language.** The caller passes all its languages in order; Samvada skips
+  the ones that are off or have no voice installed.
+- **No dependencies.** The package itself is pure Python; each voice engine runs in its own
+  folder, with pinned versions.
+
+Status: alpha. Linux (GNOME) is the tested platform.
+
+## Install
+
+```bash
+uv tool install samvada          # or: pipx install samvada, pip install samvada
+samvada voices add en zh         # once: about 290 MB, downloaded and verified
+```
+
+## Use
+
+```bash
+samvada speak en "Hello" zh "你好"   # plays in this order, then exits
+samvada status                      # where the voice goes now, and why
+samvada mute "watching TV"          # silent until `samvada unmute`
+samvada lang off fr                 # skip a language (the caller still passes it)
+samvada --session mute              # the same, for this terminal session only
+samvada online fallback             # allow edge-tts for a language that fails offline
+                                    #   (needs: pip install 'samvada[online]')
+samvada presence phone              # a chat bridge says: the owner just wrote from the phone
+samvada voices verify               # check the installed voices against their checksums
+```
+
+Exit codes: `0` played, or silent by decision; `1` a language failed; `2` bad usage.
+
+## Voice packs
+
+Every file a pack needs is pinned in `src/samvada/voices.lock`: a commit on the
+[Hugging Face Hub](https://huggingface.co) (or a URL at a commit), with its size and sha256.
+`samvada voices add` downloads from the Hub's resolve URLs, resumes partial downloads, and
+checks every file before putting it in place. Nothing needs configuring; optionally
+`HF_ENDPOINT` points at a mirror and `HF_TOKEN` lifts anonymous rate limits.
+
+| Pack | Voice | Engine | Source |
+|---|---|---|---|
+| en | `en_US-lessac-high` | Piper | `rhasspy/piper-voices` |
+| zh | `zh_CN-xiao_ya-medium` + g2pW + BERT tokenizer | Piper | `rhasspy/piper-voices`, `rhasspy/piper-checkpoints`, `google-bert/bert-base-chinese` |
+| ja | Tsukuyomi-chan | piper-plus | `ayousanz/piper-plus-tsukuyomi-chan` + NLTK data |
+| fr | `fr_FR-siwis-medium` | Piper | `rhasspy/piper-voices` |
+
+Each voice keeps its own license; see its model card on the Hub before you redistribute it.
+
+## Where things live
+
+| What | Where |
+|---|---|
+| Settings (mute, languages, online mode, sessions) | `$XDG_STATE_HOME/samvada/` |
+| Voices, engines | `$XDG_DATA_HOME/samvada/{voices,engines}/` (or `$SAMVADA_VOICES`, `$SAMVADA_ENGINES`) |
+
+## Develop
+
+```bash
+uv run pytest -q                     # fake engines, player, desktop and Hub: no audio, no network
+uv run python release/bundle.py <version> --test   # the standalone bundle and its offline test
+```
+
+## License
+
+MIT, see [LICENSE](LICENSE). The voices are not part of this package; they are downloaded
+from their own repositories under their own licenses.

samvada-20261111.1/pyproject.toml

@@ -0,0 +1,59 @@
+[project]
+# The import is samvada and the command samvada. A release stamps its version, <YYYYMMDD>.<N>,
+# here and in src/samvada/__init__.py.
+name = "samvada"
+version = "20261111.1"
+description = "Samvada: a voice and the habits of a language tutor for AI agents, offline first"
+readme = "README.md"
+authors = [
+    { name = "Cong Zhang", email = "13283869+congzhangzh@users.noreply.github.com" }
+]
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.11"
+keywords = ["tts", "text-to-speech", "offline", "piper", "ai-agent", "language-learning"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Multimedia :: Sound/Audio :: Speech",
+]
+# No dependency by default: the voices run as subprocesses in their own environments, and
+# the default install cannot reach the network (docs/DESIGN.md 4.3).
+dependencies = []
+
+[project.urls]
+Homepage = "https://github.com/congzhangzh/samvada"
+Source = "https://github.com/congzhangzh/samvada"
+Releases = "https://github.com/congzhangzh/samvada/releases"
+
+[project.optional-dependencies]
+# edge-tts: only used after `samvada online fallback|always`
+online = ["edge-tts>=7"]
+
+[project.scripts]
+samvada = "samvada.cli:main"
+# The `speak` alias (DESIGN 11) is registered at the migration step, not before: installing it
+# now would collide with the bash wrapper that is still in use.
+
+[dependency-groups]
+dev = ["pytest>=8"]
+
+[build-system]
+requires = ["hatchling>=1.25"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/samvada"]
+
+[tool.hatch.build.targets.sdist]
+include = ["src/samvada", "tests", "release", "README.md", "LICENSE", "pyproject.toml", "uv.lock"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

samvada-20261111.1/release/bundle.py

@@ -0,0 +1,189 @@
+"""Build the standalone bundle: Samvada with its own Python, engines and voice packs (DESIGN 8.2).
+
+    uv run python release/bundle.py <version> [--langs en,zh] [--out DIR] [--work DIR]
+                                              [--cache DIR] [--test]
+
+The result works on a machine with no network: unpack it anywhere and run bin/samvada.
+Layout of samvada-<version>-linux-x86_64/:
+
+    bin/samvada      the launcher (sh): sets the folders below, runs python -m samvada
+    python/          a standalone CPython (python-build-standalone, through uv)
+    lib/             samvada itself, from the wheel
+    engines/<name>/  each engine's pinned requirements (separate: both install `piper`)
+    voices/          the voice packs, verified against voices.lock
+    BUNDLE.json      what is inside and where it came from
+
+A version is never overwritten: building one that exists stops. Heavy work goes in --work and
+--cache (default under $SAMVADA_BUILD_DIR, else ~/.cache/samvada-build; never /tmp, which is
+often tmpfs, i.e. RAM). --test unpacks the archive
+in a new folder and speaks en and zh inside a container with no network (podman or docker).
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+import platform
+import shutil
+import subprocess
+import sys
+import tarfile
+import time
+import wave
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+PYTHON = "3.12"  # the engines' wheels (onnxruntime, tokenizers) are proven on it
+SCRATCH = Path(os.environ.get("SAMVADA_BUILD_DIR") or Path.home() / ".cache" / "samvada-build")
+
+LAUNCHER = """#!/bin/sh
+# Samvada standalone bundle: everything it needs is in this folder; no network needed.
+here=$(cd "$(dirname "$(readlink -f "$0")")/.." && pwd)
+export SAMVADA_VOICES="${SAMVADA_VOICES:-$here/voices}"
+export SAMVADA_ENGINES="${SAMVADA_ENGINES:-$here/engines}"
+export PYTHONPATH="$here/lib${PYTHONPATH:+:$PYTHONPATH}"
+exec "$here/python/bin/python3" -s -m samvada "$@"
+"""
+
+TEST_TEXT = {"en": "Samvada speaks offline.", "zh": "Samvada 离线说话。",
+             "ja": "サンヴァーダはオフラインで話します。", "fr": "Samvada parle hors ligne."}
+
+
+def run(cmd: list[str], **kw) -> subprocess.CompletedProcess:
+    print("+ " + " ".join(str(c) for c in cmd), flush=True)
+    return subprocess.run(cmd, check=True, **kw)
+
+
+def git_commit() -> str:
+    r = subprocess.run(["git", "-C", str(ROOT), "rev-parse", "HEAD"], capture_output=True, text=True)
+    dirty = subprocess.run(["git", "-C", str(ROOT), "status", "--porcelain", "--", "."],
+                           capture_output=True, text=True).stdout.strip()
+    return r.stdout.strip() + ("+dirty" if dirty else "")
+
+
+def sha256(path: Path) -> str:
+    h = hashlib.sha256()
+    with path.open("rb") as fh:
+        while chunk := fh.read(1 << 20):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def du(path: Path) -> int:
+    return sum(p.stat().st_size for p in path.rglob("*") if p.is_file() and not p.is_symlink())
+
+
+def build(version: str, langs: list[str], out: Path, work: Path, cache: Path) -> Path:
+    plat = f"{platform.system().lower()}-{platform.machine()}"
+    name = f"samvada-{version}-{plat}"
+    archive = out / f"{name}.tar.gz"
+    if archive.exists() or (out / name).exists():
+        sys.exit(f"bundle: {archive} exists; a version is never overwritten (pick the next one)")
+    stage = work / name
+    shutil.rmtree(stage, ignore_errors=True)
+    stage.mkdir(parents=True)
+    t0 = time.time()
+
+    wheels = work / "wheel"
+    shutil.rmtree(wheels, ignore_errors=True)
+    run(["uv", "build", "--wheel", "--out-dir", str(wheels), str(ROOT)])
+    wheel = next(wheels.glob("samvada-*.whl"))
+
+    pys = work / "python"
+    run(["uv", "python", "install", "--install-dir", str(pys), PYTHON])
+    src = sorted(p for p in pys.glob(f"cpython-{PYTHON}.*") if p.is_dir() and not p.is_symlink())[-1]
+    shutil.copytree(src, stage / "python", symlinks=True)
+    py = stage / "python" / "bin" / "python3"
+
+    run(["uv", "pip", "install", "--quiet", "--python", str(py), "--target", str(stage / "lib"),
+         "--no-deps", str(wheel)])
+    (stage / "bin").mkdir()
+    launcher = stage / "bin" / "samvada"
+    launcher.write_text(LAUNCHER)
+    launcher.chmod(0o755)
+
+    env = {**os.environ, "SAMVADA_DOWNLOAD_CACHE": str(cache),
+           "XDG_STATE_HOME": str(work / "state"), "XDG_DATA_HOME": str(work / "data")}
+    run([str(launcher), "voices", "add", *langs, "--engine", "always"], env=env)
+    run([str(launcher), "voices", "verify", *langs], env=env)
+    shutil.rmtree(work / "state", ignore_errors=True)  # never ship a builder's state
+
+    info = {
+        "name": name, "version": version, "languages": langs, "python": src.name,
+        "source_commit": git_commit(), "voices_lock_sha256": sha256(ROOT / "src/samvada/voices.lock"),
+        "built": time.strftime("%Y-%m-%dT%H:%M:%S%z"), "size_bytes": du(stage),
+    }
+    (stage / "BUNDLE.json").write_text(json.dumps(info, indent=1, ensure_ascii=False) + "\n")
+
+    out.mkdir(parents=True, exist_ok=True)
+    tmp = archive.with_name(archive.name + ".part")
+    with tarfile.open(tmp, "w:gz", compresslevel=6) as tar:
+        tar.add(stage, arcname=name)
+    tmp.replace(archive)
+    (out / f"{name}.tar.gz.sha256").write_text(f"{sha256(archive)}  {archive.name}\n")
+    print(f"bundle: {archive} ({archive.stat().st_size / 1e6:.0f} MB packed, "
+          f"{info['size_bytes'] / 1e6:.0f} MB unpacked) in {time.time() - t0:.0f}s")
+    return archive
+
+
+def wav_seconds(path: Path) -> float:
+    with wave.open(str(path)) as w:
+        return w.getnframes() / w.getframerate()
+
+
+def test(archive: Path, langs: list[str], work: Path) -> int:
+    """Unpack in a new folder (another path: it must be relocatable) and speak in a container
+    with no network, on an image with no Python at all."""
+    engine = shutil.which("podman") or shutil.which("docker")
+    if not engine:
+        sys.exit("bundle test: needs podman or docker")
+    where = work / f"test-{time.strftime('%Y%m%d-%H%M%S')}"
+    where.mkdir(parents=True)
+    with tarfile.open(archive) as tar:
+        tar.extractall(where, filter="tar")
+    folder = next(p for p in where.iterdir() if p.is_dir())
+    out = where / "out"
+    out.mkdir()
+    pairs = [x for l in langs for x in (l, TEST_TEXT[l])]
+    cmd = [engine, "run", "--rm", "--network", "none",
+           "-v", f"{folder}:/opt/samvada:ro,Z", "-v", f"{out}:/out:Z",
+           "-e", "HOME=/tmp", "debian:testing",
+           "sh", "-c", 'command -v python3 && echo "python3 found: not a clean machine" && exit 9; '
+                       '/opt/samvada/bin/samvada voices verify && '
+                       '/opt/samvada/bin/samvada speak --save /out "$@"', "sh", *pairs]
+    r = subprocess.run(cmd)
+    print(f"bundle test: container exit {r.returncode}")
+    ok = r.returncode == 0
+    for i, lang in enumerate(langs, 1):
+        clip = out / f"{i}-{lang}.wav"
+        if clip.is_file():
+            print(f"bundle test: {lang}: {clip.name} {wav_seconds(clip):.2f}s of audio")
+            ok &= wav_seconds(clip) > 0.5
+        else:
+            print(f"bundle test: {lang}: no clip")
+            ok = False
+    print(f"bundle test: {'PASSED' if ok else 'FAILED'} (network none; clips in {out})")
+    return 0 if ok else 1
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("version")
+    ap.add_argument("--langs", default="en,zh", help="the packs inside (default: en,zh)")
+    ap.add_argument("--out", type=Path, default=SCRATCH / "bundles")
+    ap.add_argument("--work", type=Path, default=SCRATCH / "work")
+    ap.add_argument("--cache", type=Path, default=SCRATCH / "download-cache")
+    ap.add_argument("--test", action="store_true", help="also run the offline container test")
+    ap.add_argument("--test-only", type=Path, metavar="ARCHIVE", help="only test this archive")
+    a = ap.parse_args()
+    langs = [l for l in a.langs.split(",") if l]
+    if a.test_only:
+        return test(a.test_only, langs, a.work)
+    archive = build(a.version, langs, a.out, a.work, a.cache)
+    return test(archive, langs, a.work) if a.test else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

samvada-20261111.1/release/lock_voices.py

@@ -0,0 +1,125 @@
+"""Write src/samvada/voices.lock: every file a voice pack needs, pinned (DESIGN 8.3, 8.4).
+
+The sources live here, each pinned to a commit. For each file the Hub's API gives the size
+and, for files in LFS, the sha256; a small file outside LFS is downloaded once to hash it.
+Also writes the engines' requirement locks (src/samvada/locks/*.txt) with `uv pip compile`.
+
+    uv run python release/lock_voices.py          # network needed; nothing is installed
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import subprocess
+import sys
+import urllib.request
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+PKG = ROOT / "src" / "samvada"
+HF = "https://huggingface.co"
+
+PIPER_VOICES = ("rhasspy/piper-voices", "model", "cf910fb59f1d79ab3b625a63993a108751c6c25d")
+CHECKPOINTS = ("rhasspy/piper-checkpoints", "dataset", "8d418f0288a50aed603547ee751193fa7910bfe3")
+BERT_ZH = ("google-bert/bert-base-chinese", "model", "8f23c25b06e129b6c986331a13d8d025a92cf0ea")
+TSUKUYOMI = ("ayousanz/piper-plus-tsukuyomi-chan", "model", "619ad26fcbd5635b3d70a27eac919f4c2ce892b1")
+NLTK = "https://raw.githubusercontent.com/nltk/nltk_data/550b6625bcef1f2abff2ff770a5a0d272c9c6b2a"
+
+# The tokenizer goes into a Hugging Face cache layout under the voices folder, named as
+# Piper asks for it ("bert-base-chinese"), so from_pretrained finds it with HF_HUB_OFFLINE=1.
+BERT_SNAP = f"hf/hub/models--bert-base-chinese/snapshots/{BERT_ZH[2]}"
+
+
+def piper_voice(pack: str, folder: str, name: str) -> list[dict]:
+    return [{"pack": pack, "hf": PIPER_VOICES, "path": f"{folder}/{name}{ext}", "dest": name + ext}
+            for ext in (".onnx", ".onnx.json")]
+
+
+SOURCES: list[dict] = [
+    *piper_voice("en", "en/en_US/lessac/high", "en_US-lessac-high"),
+    *piper_voice("zh", "zh/zh_CN/xiao_ya/medium", "zh_CN-xiao_ya-medium"),
+    {"pack": "zh", "hf": CHECKPOINTS, "path": "zh/zh_CN/_resources/g2pw.tar.gz",
+     "dest": "g2pW", "unpack": "tar"},
+    *[{"pack": "zh", "hf": BERT_ZH, "path": f, "dest": f"{BERT_SNAP}/{f}"}
+      for f in ("tokenizer_config.json", "tokenizer.json", "vocab.txt")],
+    {"pack": "ja", "hf": TSUKUYOMI, "path": "tsukuyomi-chan-6lang-fp16.onnx",
+     "dest": "tsukuyomi-chan-6lang-fp16.onnx"},
+    {"pack": "ja", "hf": TSUKUYOMI, "path": "config.json",
+     "dest": "tsukuyomi-chan-6lang-fp16.onnx.json"},
+    {"pack": "ja", "url": f"{NLTK}/packages/taggers/averaged_perceptron_tagger_eng.zip",
+     "dest": "nltk_data/taggers", "unpack": "zip"},
+    {"pack": "ja", "url": f"{NLTK}/packages/corpora/cmudict.zip",
+     "dest": "nltk_data/corpora", "unpack": "zip"},
+    *piper_voice("fr", "fr/fr_FR/siwis/medium", "fr_FR-siwis-medium"),
+]
+
+ENGINES = {
+    "piper": "piper-tts[zh]==1.8.0",
+    "piper-plus": "piper-plus==1.13.0",
+}
+
+
+def get(url: str) -> bytes:
+    req = urllib.request.Request(url, headers={"User-Agent": "samvada-lock"})
+    with urllib.request.urlopen(req, timeout=120) as r:
+        return r.read()
+
+
+def tree(repo: str, kind: str, rev: str, folder: str) -> dict[str, dict]:
+    prefix = "datasets/" if kind == "dataset" else "models/"
+    url = f"{HF}/api/{prefix}{repo}/tree/{rev}/{folder}".rstrip("/")
+    return {f["path"]: f for f in json.loads(get(url))}
+
+
+def resolve(src: dict) -> dict:
+    out = {"pack": src["pack"]}
+    if "hf" in src:
+        repo, kind, rev = src["hf"]
+        folder = src["path"].rpartition("/")[0]
+        info = tree(repo, kind, rev, folder)[src["path"]]
+        out |= {"repo": repo, "repo_type": kind, "revision": rev, "path": src["path"]}
+        size, sha = info["size"], (info.get("lfs") or {}).get("oid")
+        if not sha:  # a small file outside LFS: hash it
+            prefix = "datasets/" if kind == "dataset" else ""
+            data = get(f"{HF}/{prefix}{repo}/resolve/{rev}/{src['path']}")
+            assert len(data) == size, src
+            sha = hashlib.sha256(data).hexdigest()
+    else:
+        data = get(src["url"])
+        out["url"] = src["url"]
+        size, sha = len(data), hashlib.sha256(data).hexdigest()
+    out |= {"dest": src["dest"], "unpack": src.get("unpack", ""), "size": size, "sha256": sha}
+    return out
+
+
+def toml_value(v) -> str:
+    return str(v) if isinstance(v, int) else json.dumps(v, ensure_ascii=False)
+
+
+def main() -> int:
+    lines = ["# Generated by release/lock_voices.py: do not edit by hand.",
+             "# Every file a voice pack needs, pinned: a Hub commit (or a URL at a commit),",
+             "# its size and sha256. `samvada voices add` downloads and verifies against it.", ""]
+    for src in SOURCES:
+        f = resolve(src)
+        print(f"{f['pack']}  {f['size']:>11}  {f['sha256'][:12]}  {f['dest']}", file=sys.stderr)
+        lines.append("[[file]]")
+        lines += [f"{k} = {toml_value(v)}" for k, v in f.items()]
+        lines.append("")
+    lines += ["[engines]"] + [f"{k} = {toml_value(v)}" for k, v in ENGINES.items()]
+    (PKG / "voices.lock").write_text("\n".join(lines) + "\n")
+
+    locks = PKG / "locks"
+    locks.mkdir(exist_ok=True)
+    for name, req in ENGINES.items():
+        out = locks / f"{name}.txt"
+        subprocess.run(["uv", "pip", "compile", "--universal", "--quiet", "--no-header",
+                        "--python-version", "3.12", "-o", str(out), "-"],
+                       input=req + "\n", text=True, check=True)
+        print(f"engine {name}: {out.relative_to(ROOT)}", file=sys.stderr)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

samvada-20261111.1/src/samvada/__init__.py

@@ -0,0 +1,6 @@
+"""Samvada: a voice and the habits of a language tutor for AI agents, offline first.
+
+The agent decides what to say; Samvada decides whether, where and how it is heard.
+"""
+
+__version__ = "20261111.1"

samvada-20261111.1/src/samvada/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+import sys
+sys.exit(main())

samvada-20261111.1/src/samvada/agents/__init__.py

@@ -0,0 +1 @@
+"""The agent layer: the rule, the skill, the hooks and `samvada setup` (DESIGN 7)."""