python-voiceio 1.1.0__tar.gz → 1.3.0__tar.gz

{python_voiceio-1.1.0/python_voiceio.egg-info → python_voiceio-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-voiceio
-Version: 1.1.0
+Version: 1.3.0
 Summary: Voice dictation for Linux. Speak → text, locally, instantly.
 Author: Hugo Montenegro
 License-Expression: MIT
@@ -182,7 +182,8 @@ Most dictation errors are proper nouns and jargon: `PostgreSQL` heard as `post g
 voiceio learn import DIR --source phone   # optional: add your own recordings from elsewhere
 voiceio learn label      # a stronger teacher model (large-v3-turbo) transcribes your clips
 voiceio learn review     # fix the teacher where it matters: your names and terms
-voiceio learn review --test   # once: verify the held-out clips, so eval scores against the truth
+voiceio learn review --test   # verify the held-out clips, so eval scores against the truth: it asks only
+                              #   where the teacher and your live decode disagree, quickest clips first
 voiceio learn augment    # synthesize extra examples of rare terms with local TTS
 voiceio learn build      # freeze a versioned train/dev/test dataset (the test split never trains)
 voiceio learn eval       # score the current model on your held-out clips: WER and term recall
@@ -191,6 +192,7 @@ voiceio learn train      # LoRA fine-tune (needs the `train` extra; decoder-only
 voiceio learn promote <run>   # dictate with the fine-tune; `voiceio learn rollback` undoes it
 voiceio learn maintain   # later: label what's new, and once 50+ clips piled up, retrain and compare
 voiceio learn schedule on   # …or let it run `maintain` every night, and notify you when a model wins
+                            #   (--auto-promote: switch to a winner by itself; `learn rollback` undoes it)
 ```
 
 Labeling, training and offline eval run in an idle-priority cgroup, so they never slow dictation down. Everything stays on your machine unless you choose `train --remote`.
@@ -292,7 +294,7 @@ There is a best-effort pynput path for both (hotkeys and typing, no live preview
 | Hotkey does nothing on Wayland | `voiceio doctor --fix` installs the keyboard udev rule, or bind `voiceio toggle` in your compositor |
 | `sounddevice is not installed` | You installed without the desktop extra: `pipx install --force 'python-voiceio[desktop]'` |
 | evdev fails to build | Install a C toolchain and Python headers (see Quickstart), then reinstall |
-| Too slow | `voiceio doctor` shows your real stop→text; turn off cloud postcorrect, or `voiceio models use small` (or a GPU with `large-v3-turbo`) |
+| Too slow | `voiceio doctor` shows your real stop→text. Turn off cloud postcorrect; use `voiceio models use small` (or a GPU with `large-v3-turbo`); or narrow the beam of the passes you keep: on the author's 44 clips `[model] beam_size = 2` matched the default 5 (WER 4.9% vs 5.4%, vocabulary 28/32 vs 29/32) while decoding faster; greedy (`1`) lost vocabulary (26/32). Measure on yours: `voiceio learn eval --beam 2` |
 | Words come out wrong in a pattern | `voiceio learn eval --pipeline` and `voiceio corrections audit` show which stage or rule did it |
 | Start over | `voiceio uninstall`, then `voiceio setup` |
 
@@ -300,8 +302,7 @@ Logs: `journalctl --user -u voiceio` or `~/.local/state/voiceio/voiceio.log`.
 
 ## Roadmap
 
-- **A landing page** — voiceio as local, open-source, private dictation that learns from you.
-- **Hands-off promotion** — `learn schedule` already retrains nightly and tells you when a model wins; next is switching to it automatically, with one-command rollback.
+- **A landing page** — voiceio as local, open-source, private dictation that learns from you. A draft is in [`site/index.html`](site/index.html), ready for GitHub Pages.
 - **Unbounded vocabulary** — move to a decoder whose biasing has no token cap (see [model choice](CONTRIBUTING.md#model-choice-why-whisper-and-what-would-change-it)).
 - **One model everywhere** — sync your fine-tune to your phone server and laptops, peer to peer.
 

{python_voiceio-1.1.0 → python_voiceio-1.3.0}/README.md

@@ -129,7 +129,8 @@ Most dictation errors are proper nouns and jargon: `PostgreSQL` heard as `post g
 voiceio learn import DIR --source phone   # optional: add your own recordings from elsewhere
 voiceio learn label      # a stronger teacher model (large-v3-turbo) transcribes your clips
 voiceio learn review     # fix the teacher where it matters: your names and terms
-voiceio learn review --test   # once: verify the held-out clips, so eval scores against the truth
+voiceio learn review --test   # verify the held-out clips, so eval scores against the truth: it asks only
+                              #   where the teacher and your live decode disagree, quickest clips first
 voiceio learn augment    # synthesize extra examples of rare terms with local TTS
 voiceio learn build      # freeze a versioned train/dev/test dataset (the test split never trains)
 voiceio learn eval       # score the current model on your held-out clips: WER and term recall
@@ -138,6 +139,7 @@ voiceio learn train      # LoRA fine-tune (needs the `train` extra; decoder-only
 voiceio learn promote <run>   # dictate with the fine-tune; `voiceio learn rollback` undoes it
 voiceio learn maintain   # later: label what's new, and once 50+ clips piled up, retrain and compare
 voiceio learn schedule on   # …or let it run `maintain` every night, and notify you when a model wins
+                            #   (--auto-promote: switch to a winner by itself; `learn rollback` undoes it)
 ```
 
 Labeling, training and offline eval run in an idle-priority cgroup, so they never slow dictation down. Everything stays on your machine unless you choose `train --remote`.
@@ -239,7 +241,7 @@ There is a best-effort pynput path for both (hotkeys and typing, no live preview
 | Hotkey does nothing on Wayland | `voiceio doctor --fix` installs the keyboard udev rule, or bind `voiceio toggle` in your compositor |
 | `sounddevice is not installed` | You installed without the desktop extra: `pipx install --force 'python-voiceio[desktop]'` |
 | evdev fails to build | Install a C toolchain and Python headers (see Quickstart), then reinstall |
-| Too slow | `voiceio doctor` shows your real stop→text; turn off cloud postcorrect, or `voiceio models use small` (or a GPU with `large-v3-turbo`) |
+| Too slow | `voiceio doctor` shows your real stop→text. Turn off cloud postcorrect; use `voiceio models use small` (or a GPU with `large-v3-turbo`); or narrow the beam of the passes you keep: on the author's 44 clips `[model] beam_size = 2` matched the default 5 (WER 4.9% vs 5.4%, vocabulary 28/32 vs 29/32) while decoding faster; greedy (`1`) lost vocabulary (26/32). Measure on yours: `voiceio learn eval --beam 2` |
 | Words come out wrong in a pattern | `voiceio learn eval --pipeline` and `voiceio corrections audit` show which stage or rule did it |
 | Start over | `voiceio uninstall`, then `voiceio setup` |
 
@@ -247,8 +249,7 @@ Logs: `journalctl --user -u voiceio` or `~/.local/state/voiceio/voiceio.log`.
 
 ## Roadmap
 
-- **A landing page** — voiceio as local, open-source, private dictation that learns from you.
-- **Hands-off promotion** — `learn schedule` already retrains nightly and tells you when a model wins; next is switching to it automatically, with one-command rollback.
+- **A landing page** — voiceio as local, open-source, private dictation that learns from you. A draft is in [`site/index.html`](site/index.html), ready for GitHub Pages.
 - **Unbounded vocabulary** — move to a decoder whose biasing has no token cap (see [model choice](CONTRIBUTING.md#model-choice-why-whisper-and-what-would-change-it)).
 - **One model everywhere** — sync your fine-tune to your phone server and laptops, peer to peer.
 

{python_voiceio-1.1.0 → python_voiceio-1.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-voiceio"
-version = "1.1.0"
+version = "1.3.0"
 description = "Voice dictation for Linux. Speak → text, locally, instantly."
 readme = "README.md"
 license = "MIT"

{python_voiceio-1.1.0 → python_voiceio-1.3.0/python_voiceio.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-voiceio
-Version: 1.1.0
+Version: 1.3.0
 Summary: Voice dictation for Linux. Speak → text, locally, instantly.
 Author: Hugo Montenegro
 License-Expression: MIT
@@ -182,7 +182,8 @@ Most dictation errors are proper nouns and jargon: `PostgreSQL` heard as `post g
 voiceio learn import DIR --source phone   # optional: add your own recordings from elsewhere
 voiceio learn label      # a stronger teacher model (large-v3-turbo) transcribes your clips
 voiceio learn review     # fix the teacher where it matters: your names and terms
-voiceio learn review --test   # once: verify the held-out clips, so eval scores against the truth
+voiceio learn review --test   # verify the held-out clips, so eval scores against the truth: it asks only
+                              #   where the teacher and your live decode disagree, quickest clips first
 voiceio learn augment    # synthesize extra examples of rare terms with local TTS
 voiceio learn build      # freeze a versioned train/dev/test dataset (the test split never trains)
 voiceio learn eval       # score the current model on your held-out clips: WER and term recall
@@ -191,6 +192,7 @@ voiceio learn train      # LoRA fine-tune (needs the `train` extra; decoder-only
 voiceio learn promote <run>   # dictate with the fine-tune; `voiceio learn rollback` undoes it
 voiceio learn maintain   # later: label what's new, and once 50+ clips piled up, retrain and compare
 voiceio learn schedule on   # …or let it run `maintain` every night, and notify you when a model wins
+                            #   (--auto-promote: switch to a winner by itself; `learn rollback` undoes it)
 ```
 
 Labeling, training and offline eval run in an idle-priority cgroup, so they never slow dictation down. Everything stays on your machine unless you choose `train --remote`.
@@ -292,7 +294,7 @@ There is a best-effort pynput path for both (hotkeys and typing, no live preview
 | Hotkey does nothing on Wayland | `voiceio doctor --fix` installs the keyboard udev rule, or bind `voiceio toggle` in your compositor |
 | `sounddevice is not installed` | You installed without the desktop extra: `pipx install --force 'python-voiceio[desktop]'` |
 | evdev fails to build | Install a C toolchain and Python headers (see Quickstart), then reinstall |
-| Too slow | `voiceio doctor` shows your real stop→text; turn off cloud postcorrect, or `voiceio models use small` (or a GPU with `large-v3-turbo`) |
+| Too slow | `voiceio doctor` shows your real stop→text. Turn off cloud postcorrect; use `voiceio models use small` (or a GPU with `large-v3-turbo`); or narrow the beam of the passes you keep: on the author's 44 clips `[model] beam_size = 2` matched the default 5 (WER 4.9% vs 5.4%, vocabulary 28/32 vs 29/32) while decoding faster; greedy (`1`) lost vocabulary (26/32). Measure on yours: `voiceio learn eval --beam 2` |
 | Words come out wrong in a pattern | `voiceio learn eval --pipeline` and `voiceio corrections audit` show which stage or rule did it |
 | Start over | `voiceio uninstall`, then `voiceio setup` |
 
@@ -300,8 +302,7 @@ Logs: `journalctl --user -u voiceio` or `~/.local/state/voiceio/voiceio.log`.
 
 ## Roadmap
 
-- **A landing page** — voiceio as local, open-source, private dictation that learns from you.
-- **Hands-off promotion** — `learn schedule` already retrains nightly and tells you when a model wins; next is switching to it automatically, with one-command rollback.
+- **A landing page** — voiceio as local, open-source, private dictation that learns from you. A draft is in [`site/index.html`](site/index.html), ready for GitHub Pages.
 - **Unbounded vocabulary** — move to a decoder whose biasing has no token cap (see [model choice](CONTRIBUTING.md#model-choice-why-whisper-and-what-would-change-it)).
 - **One model everywhere** — sync your fine-tune to your phone server and laptops, peer to peer.
 

{python_voiceio-1.1.0 → python_voiceio-1.3.0}/tests/test_health.py

@@ -105,3 +105,21 @@ def test_usage_decoder_counts_incidents_on_the_current_release(tmp_path, monkeyp
     assert ok
     assert finding.startswith(f"decoder: 0 hangs, 1 crashes in the last 7 days on {__version__}")
     assert f"(1 more before {__version__})" in finding
+
+
+def test_learning_status_and_tips(monkeypatch):
+    from voiceio import config, service
+    from voiceio.health import _accuracy_tips, _learning_status
+    from voiceio.learn.store import learn_dir
+    monkeypatch.setattr(service, "learn_timer_enabled", lambda: False)
+    cfg = config.Config()
+    st = _learning_status(cfg)
+    assert st["Voice model"] == "stock (small)" and st["Recordings"].startswith("off")
+    assert any("retain_audio true" in t for t in _accuracy_tips(st))
+
+    cfg.data.retain_audio = True
+    cfg.model.name = str(learn_dir() / "models" / "v0001-small-x" / "ct2")
+    st = _learning_status(cfg)
+    assert st["Voice model"] == "fine-tuned on you (v0001-small-x)"
+    assert st["Recordings"].startswith("on (") and st["Nightly learning"] == "off"
+    assert any("learn schedule on" in t for t in _accuracy_tips(st))

{python_voiceio-1.1.0 → python_voiceio-1.3.0}/tests/test_learn_pipeline.py

@@ -132,14 +132,34 @@ def test_learn_jobs_reexec_into_an_idle_scope(monkeypatch):
 
 
 def test_promotion_requires_a_winning_eval():
-    base = {"wer": 0.10, "term_recall": 0.40, "repetitions": 0}
-    better = {"wer": 0.101, "term_recall": 0.70, "repetitions": 0}   # vocab win, WER within slack
-    worse = {"wer": 0.13, "term_recall": 0.70, "repetitions": 0}
+    base = {"wer": 0.10, "term_recall": 0.40, "repetitions": 0, "clips": 44}
+    better = {"wer": 0.101, "term_recall": 0.70, "repetitions": 0, "clips": 44}   # vocab win
+    worse = {"wer": 0.13, "term_recall": 0.70, "repetitions": 0, "clips": 44}
     assert evaluate.promotion_verdict(better, base)[0]
     assert not evaluate.promotion_verdict(worse, base)[0]
     assert not evaluate.promotion_verdict({**better, "repetitions": 2}, base)[0]
 
 
+def test_no_promotion_without_evidence():
+    """A crashed decode scores 0% WER; an empty test split scores nothing."""
+    base = {"wer": 0.10, "term_recall": 0.40, "repetitions": 0, "clips": 44}
+    perfect = {"wer": 0.0, "term_recall": 1.0, "repetitions": 0}
+    assert not evaluate.promotion_verdict({**perfect, "clips": 44, "failures": 3}, base)[0]
+    assert not evaluate.promotion_verdict({**perfect, "clips": 40}, base)[0]      # other clips
+    assert not evaluate.promotion_verdict({**perfect, "clips": 2}, {**base, "clips": 2})[0]
+
+
+def test_latest_finds_runs_at_the_configured_beam():
+    runs = store.learn_dir() / "runs"
+    runs.mkdir(parents=True)
+    for i, (dec, wer) in enumerate([("faster-whisper:small", 5), ("faster-whisper:small@beam2+draft", 2)]):
+        (runs / f"eval-2026010{i}.json").write_text(json.dumps(
+            {"decoder": dec, "dataset": "v0001", "wer": wer, "metrics": metrics.METRICS_VERSION}))
+    assert evaluate.latest("small", "v0001")["wer"] == 5
+    assert evaluate.latest("small", "v0001", beam=2)["wer"] == 2
+    assert evaluate.latest("small", "v0001", beam=1) is None
+
+
 def test_latest_eval_matches_model_dataset_and_mode():
     runs = store.learn_dir() / "runs"
     runs.mkdir(parents=True)
@@ -230,11 +250,27 @@ def test_maintain_waits_for_enough_new_clips(monkeypatch, capsys):
     store.add_label("new.wav", [Segment(0, 3, "a new one")], "teacher:fake")
 
     monkeypatch.setattr(cli, "cmd_label", lambda args: None)
+    monkeypatch.setattr(train, "missing_train_deps", lambda: [])
     monkeypatch.setattr(cli, "_train", lambda *a, **k: pytest.fail("must not retrain"))
     cli.cmd_maintain(argparse.Namespace(min_new=5, base="small", epochs=1))
     assert "1 new labeled clips since v0001" in capsys.readouterr().out
 
 
+def test_maintain_without_train_extra_labels_and_exits_cleanly(monkeypatch, capsys):
+    """A nightly timer must not fail every night, or spend an eval, over an
+    optional install."""
+    import argparse
+
+    from voiceio.cli import learn as cli
+    labeled = []
+    monkeypatch.setattr(cli, "cmd_label", lambda args: labeled.append(True))
+    monkeypatch.setattr(train, "missing_train_deps", lambda: ["torch", "peft"])
+    monkeypatch.setattr(store, "build_dataset", lambda: pytest.fail("must not build"))
+    monkeypatch.setattr(cli, "_run_eval", lambda *a, **k: pytest.fail("must not eval"))
+    cli.cmd_maintain(argparse.Namespace(min_new=5, base="small", epochs=1))
+    assert labeled and "python-voiceio[train]" in capsys.readouterr().out
+
+
 def test_dev_mix_is_stable_per_row():
     assert train._row_draws("a.wav") == train._row_draws("a.wav")
     assert train._row_draws("a.wav") != train._row_draws("b.wav")
@@ -292,3 +328,41 @@ def test_wait_summary_p90_never_exceeds_max():
     s = r.wait_summary()
     p90 = float(s.split("p90 ")[1].split("s")[0])
     assert p90 <= 6.83
+
+
+def test_maintain_auto_promote_switches_restarts_and_says_how_to_undo(monkeypatch):
+    import argparse
+    from types import SimpleNamespace
+
+    from voiceio import feedback, service
+    from voiceio.cli import learn as cli
+    from voiceio.learn import evaluate
+    for i in range(3):
+        _clip(f"{i}.wav", 3, "x")
+        store.add_label(f"{i}.wav", [Segment(0, 3, "hello there")], "teacher:fake")
+    run = store.learn_dir() / "models" / "v0001-small-x"
+    calls = []
+    monkeypatch.setattr(cli, "cmd_label", lambda a: None)
+    monkeypatch.setattr(train, "missing_train_deps", lambda: [])
+    monkeypatch.setattr(cli, "_run_eval", lambda *a, **k: SimpleNamespace(
+        wer=0.1, term_recall=0.5, repetitions=0, per_clip=[]))
+    monkeypatch.setattr(cli, "_train", lambda *a, **k: run)
+    monkeypatch.setattr(evaluate, "promotion_verdict", lambda c, b: (True, "table"))
+    monkeypatch.setattr(cli, "cmd_promote", lambda a: calls.append(("promote", a.run)))
+    monkeypatch.setattr(service, "is_installed", lambda: True)
+    monkeypatch.setattr(service, "restart_when_idle", lambda: calls.append(("restart",)) or True)
+    monkeypatch.setattr(feedback, "notify", lambda t, b, urgent=False: calls.append(("notify", b)))
+
+    cli.cmd_maintain(argparse.Namespace(min_new=1, base="small", epochs=1, auto_promote=True))
+    assert calls[:2] == [("promote", "v0001-small-x"), ("restart",)]
+    assert "voiceio learn rollback" in calls[2][1]
+
+    # The gate's own re-check refuses: no restart, no "switched" notification,
+    # and no crash (the nightly unit must not fail).
+    calls.clear()
+
+    def refuse(a):
+        raise SystemExit("evaluate both models first")
+    monkeypatch.setattr(cli, "cmd_promote", refuse)
+    cli.cmd_maintain(argparse.Namespace(min_new=1, base="small", epochs=1, auto_promote=True))
+    assert calls == []

python_voiceio-1.3.0/tests/test_learn_review.py

@@ -0,0 +1,44 @@
+
+
+def test_queue_all_covers_every_segment_of_unreviewed_clips():
+    from voiceio.learn import review
+    from voiceio.learn.store import Clip, Label, Segment
+    a = Clip("a.wav", 0, 4, "", "")
+    b = Clip("b.wav", 0, 4, "", "")
+    segs = (Segment(0, 2, "one"), Segment(2, 4, "two"))
+    labels = {"a.wav": Label("a.wav", segs, "teacher:x", 0),
+              "b.wav": Label("b.wav", segs, "human", 0)}
+    items = review.queue_all([a, b], labels)
+    assert [(i.clip.audio, i.index) for i in items] == [("a.wav", 0), ("a.wav", 1)]
+
+
+def test_live_span_shows_the_live_decode_only_where_it_differs():
+    from voiceio.learn.review import live_span
+    live = "okay so we use kalchi daily and then more stuff"
+    assert live_span("We use Kalshi daily.", live) == "we use kalchi daily"
+    assert live_span("We use Kalshi daily.", "so we use Kalshi daily ok") is None
+    assert live_span("totally different words here", "nothing alike at all") is None
+
+
+def test_gold_review_asks_only_where_the_models_disagree_cheapest_clip_first():
+    from voiceio.learn import review
+    from voiceio.learn.store import Clip, Label, Segment
+    segs = (Segment(0, 2, "we use Kalshi daily"), Segment(2, 4, "ship it today"))
+    two = Clip("two.wav", 0, 4, "we use kalchi daily ship it to day", "")
+    one = Clip("one.wav", 0, 4, "we use kalchi daily ship it today", "")
+    agree = Clip("agree.wav", 0, 4, "we use Kalshi daily ship it today", "")
+    labels = {c.audio: Label(c.audio, segs, "teacher:x", 0) for c in (two, one, agree)}
+    items = review.queue_all([two, one, agree], labels)
+    assert [(i.clip.audio, i.index) for i in items] == [
+        ("one.wav", 0),                       # one answer completes a gold clip
+        ("two.wav", 0), ("two.wav", 1),
+    ]                                         # agree.wav: nothing to ask
+
+
+def test_gold_review_counts_one_misheard_term_as_disagreement():
+    from voiceio.learn import review
+    from voiceio.learn.store import Clip, Label, Segment
+    segs = (Segment(0, 4, "we ship the Kalshi bot every single day"),)
+    clip = Clip("a.wav", 0, 4, "we ship the kalchi bot every single day", "")
+    items = review.queue_all([clip], {"a.wav": Label("a.wav", segs, "teacher:x", 0)})
+    assert len(items) == 1

python_voiceio-1.3.0/tests/test_service.py

@@ -0,0 +1,93 @@
+import sys
+from pathlib import Path
+
+from voiceio import service
+
+
+def test_install_symlinks_relinks_and_drops_legacy(monkeypatch, tmp_path):
+    venv_bin = tmp_path / "venv" / "bin"
+    venv_bin.mkdir(parents=True)
+    for name in service.SCRIPT_NAMES:
+        (venv_bin / name).write_text("#!/bin/sh\n")
+    old = tmp_path / "old"
+    old.mkdir()
+    local_bin = tmp_path / "local-bin"
+    local_bin.mkdir()
+    (local_bin / "voiceio").symlink_to(old / "voiceio")        # stale install
+    (local_bin / "voiceio-doctor").symlink_to(old / "voiceio-doctor")
+    monkeypatch.setattr(service, "LOCAL_BIN", local_bin)
+    monkeypatch.setattr(sys, "prefix", str(tmp_path / "venv"))
+    monkeypatch.setattr(service, "_is_pipx_install", lambda: False)
+    monkeypatch.setattr(service, "_local_bin_on_path", lambda: True)
+
+    assert service.install_symlinks() == service.SCRIPT_NAMES
+    assert Path(local_bin / "voiceio").resolve() == (venv_bin / "voiceio").resolve()
+    assert not (local_bin / "voiceio-doctor").is_symlink()
+
+
+def test_learn_timer_runs_maintain_at_idle_priority(monkeypatch, tmp_path):
+    calls = []
+    monkeypatch.setattr(service, "has_systemd", lambda: True)
+    monkeypatch.setattr(service, "_systemctl", lambda *a: calls.append(a) or True)
+    monkeypatch.setattr(service, "_find_voiceio_bin", lambda: "/opt/v/bin/voiceio")
+    monkeypatch.setattr(service, "SERVICE_DIR", tmp_path)
+    monkeypatch.setattr(service, "LEARN_SERVICE_PATH", tmp_path / service.LEARN_SERVICE_NAME)
+    monkeypatch.setattr(service, "LEARN_TIMER_PATH", tmp_path / service.LEARN_TIMER_NAME)
+
+    assert service.install_learn_timer()
+    unit = service.LEARN_SERVICE_PATH.read_text()
+    assert "ExecStart=/opt/v/bin/voiceio learn maintain" in unit
+    assert "CPUWeight=idle" in unit and "VOICEIO_IDLE_SCOPE=1" in unit
+    assert "Persistent=true" in service.LEARN_TIMER_PATH.read_text()
+    assert ("enable", "--now", service.LEARN_TIMER_NAME) in calls
+
+    service.uninstall_learn_timer()
+    assert not service.LEARN_TIMER_PATH.exists() and not service.LEARN_SERVICE_PATH.exists()
+
+
+def test_daemon_publishes_state_and_restart_waits_for_idle(monkeypatch):
+    import threading
+
+    from voiceio import config, pidlock
+    from voiceio.app import VoiceIO, _State
+    from voiceio.cli.servicecmd import wait_until_idle
+
+    vio = VoiceIO.__new__(VoiceIO)
+    vio._state = _State.RECORDING                      # not the lock holder:
+    assert not config.STATE_PATH.exists()              # says nothing
+    vio._publishes_state = True
+    vio._state = _State.RECORDING
+    assert config.STATE_PATH.read_text() == "recording"
+
+    monkeypatch.setattr(pidlock, "daemon_alive", lambda path: False)
+    assert wait_until_idle(timeout=5)                  # dead daemon: stale file, no wait
+    monkeypatch.setattr(pidlock, "daemon_alive", lambda path: True)
+    threading.Timer(0.3, lambda: setattr(vio, "_state", _State.IDLE)).start()
+    assert wait_until_idle(timeout=5, poll=0.05)       # waited for the dictation
+    vio._state = _State.FINALIZING                     # a hung finalize: short budget
+    assert not wait_until_idle(timeout=60, poll=0.05, finalizing_timeout=0.2)
+
+
+def test_daemon_alive_probes_the_pid_lock(tmp_path):
+    import fcntl
+
+    from voiceio.pidlock import daemon_alive
+    path = tmp_path / "voiceio.pid"
+    assert not daemon_alive(path)
+    with open(path, "a") as held:
+        fcntl.flock(held, fcntl.LOCK_EX)
+        assert daemon_alive(path)
+    assert not daemon_alive(path)
+
+
+def test_learn_timer_auto_promote_is_opt_in(monkeypatch, tmp_path):
+    monkeypatch.setattr(service, "has_systemd", lambda: True)
+    monkeypatch.setattr(service, "_systemctl", lambda *a: True)
+    monkeypatch.setattr(service, "_find_voiceio_bin", lambda: "voiceio")
+    monkeypatch.setattr(service, "LEARN_SERVICE_PATH", tmp_path / "s.service")
+    monkeypatch.setattr(service, "LEARN_TIMER_PATH", tmp_path / "s.timer")
+    service.install_learn_timer()
+    assert not service.learn_timer_auto_promotes()
+    service.install_learn_timer(auto_promote=True)
+    assert "learn maintain --auto-promote" in service.LEARN_SERVICE_PATH.read_text()
+    assert service.learn_timer_auto_promotes()

{python_voiceio-1.1.0 → python_voiceio-1.3.0}/tests/test_setup.py

@@ -265,3 +265,18 @@ def test_retention_is_written_only_when_asked(cfg_paths):
     assert config.load(cfg_paths).data.retain_audio is False      # off unless chosen
     configfile._write_config(**kw, retain_audio=True)
     assert config.load(cfg_paths).data.retain_audio is True
+
+
+def test_setup_offers_nightly_learning_once(monkeypatch):
+    from voiceio import service
+    from voiceio.setup import steps
+    installed = []
+    monkeypatch.setattr(service, "has_systemd", lambda: True)
+    monkeypatch.setattr(service, "learn_timer_enabled", lambda: bool(installed))
+    monkeypatch.setattr(service, "install_learn_timer", lambda: installed.append(1) or True)
+    asked = []
+    monkeypatch.setattr(steps, "_ask_yn", lambda q, default=True: asked.append(q) or True)
+    state = steps.SetupState(checks={"is_linux": True})
+    steps._offer_nightly_learning(state)
+    steps._offer_nightly_learning(state)      # already on: not asked again
+    assert installed == [1] and len(asked) == 1

{python_voiceio-1.1.0 → python_voiceio-1.3.0}/tests/test_transcriber.py

@@ -313,3 +313,14 @@ def test_no_log_call_formats_the_transcript_itself():
                     and any(leaks(a) for a in node.args[1:])):
                 hits.append(f"{path.name}:{node.lineno}")
     assert not hits, hits
+
+
+def test_non_default_beam_is_scored_under_its_own_name():
+    """An eval at beam 1 must not stand in for the model's default score."""
+    mock_proc = MagicMock()
+    mock_proc.stdout.readline.return_value = "READY\n"
+    mock_proc.poll.return_value = None
+    with patch("voiceio.core.decoders.faster_whisper.subprocess.Popen", return_value=mock_proc):
+        from voiceio.core.decoders.faster_whisper import Transcriber
+        assert Transcriber(ModelConfig()).name == "faster-whisper:small"
+        assert Transcriber(ModelConfig(beam_size=1)).name == "faster-whisper:small@beam1"

python_voiceio-1.3.0/voiceio/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.3.0"

{python_voiceio-1.1.0 → python_voiceio-1.3.0}/voiceio/app.py

@@ -36,6 +36,24 @@ class _State(enum.Enum):
 
 
 class VoiceIO:
+    @property
+    def _state(self) -> _State:
+        return self.__state
+
+    @_state.setter
+    def _state(self, value: _State) -> None:
+        self.__state = value
+        # Only the instance holding the PID lock speaks for the daemon: a
+        # second launch must not overwrite the running one's state.
+        if not getattr(self, "_publishes_state", False):
+            return
+        try:   # best-effort: only `service restart` reads it
+            tmp = config.STATE_PATH.with_suffix(".tmp")
+            tmp.write_text(value.value)
+            tmp.replace(config.STATE_PATH)
+        except OSError:
+            pass
+
     def __init__(self, cfg: config.Config):
         self.cfg = cfg
 
@@ -646,7 +664,7 @@ class VoiceIO:
         self._typers.redetect_at_start()
 
         LOG_DIR.mkdir(parents=True, exist_ok=True)
-        self._pid_fd = open(PID_PATH, "w")
+        self._pid_fd = open(PID_PATH, "a")   # not "w": the running daemon's PID stays
         try:
             from voiceio.pidlock import lock_pid_file
             lock_pid_file(self._pid_fd)
@@ -655,8 +673,11 @@ class VoiceIO:
             log.error("Another voiceio instance is already running")
             print("voiceio is already running. Stop it first: voiceio service stop")
             return
+        self._pid_fd.truncate(0)
         self._pid_fd.write(str(os.getpid()))
         self._pid_fd.flush()
+        self._publishes_state = True
+        self._state = self._state
 
         self._typers.prepare()
 
@@ -713,4 +734,5 @@ class VoiceIO:
             self._ibus.shutdown()
             self._pid_fd.close()
             PID_PATH.unlink(missing_ok=True)
+            config.STATE_PATH.unlink(missing_ok=True)
         log.info("voiceio stopped")