python-voiceio 1.2.0__py3-none-any.whl → 1.3.0__py3-none-any.whl

{python_voiceio-1.2.0.dist-info → python_voiceio-1.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-voiceio
-Version: 1.2.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`.
@@ -301,7 +303,6 @@ 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. A draft is in [`site/index.html`](site/index.html), ready for GitHub Pages.
-- **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.
 - **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.2.0.dist-info → python_voiceio-1.3.0.dist-info}/RECORD

@@ -1,7 +1,7 @@
-python_voiceio-1.2.0.dist-info/licenses/LICENSE,sha256=Gz61o8jFTAvZUZyB3nWDB3DQQVuipjfPkVu9W8hBHM0,1072
-voiceio/__init__.py,sha256=MpAT5hgNoHnTtG1XRD_GV_A7QrHVU6vJjGSw_8qMGA4,22
+python_voiceio-1.3.0.dist-info/licenses/LICENSE,sha256=Gz61o8jFTAvZUZyB3nWDB3DQQVuipjfPkVu9W8hBHM0,1072
+voiceio/__init__.py,sha256=F5mW07pSyGrqDNY2Ehr-UpDzpBtN-FsYU0QGZWf6PJE,22
 voiceio/__main__.py,sha256=xT5QCGGreYMisHO7Lh_Y-xAQ2TOzG2D7npKknGNcWSY,53
-voiceio/app.py,sha256=_FfrMN1MFWk8H5KciGu2niJm3fZJlNR2Ju9mP9s5brk,31798
+voiceio/app.py,sha256=K9vz9iZRRTavyWNYaZMYxwsvaPJBRYcQjFFyi4YOfOM,32164
 voiceio/audio_source.py,sha256=rR6NRtNzmZ8uqmNPxareBWTJmuBaOxIGI5QINR_l-qc,9102
 voiceio/backends.py,sha256=-rs1YhPblub4NjFb6qCD7Ih9FqBRXtPuvjVv9bQoQ1w,368
 voiceio/clipboard_read.py,sha256=lz75CkRGh7pyvO6xvoUmxJDl-Gwie1xlXQHK70PO84I,4261
@@ -12,13 +12,13 @@ voiceio/corrections.py,sha256=IIRViwjL9kkMy26-1dd0DtTfT0Tiedn6pmmHoaeayMQ,10047
 voiceio/demo.py,sha256=jA282e7UWDwtP1IXT2bPHH5wl6eKdBNvOJcoNDWzZlQ,8766
 voiceio/display.py,sha256=ZGBNRjuvg3chkJjduyPJs4s5ZY5vqC_mcaov94PIPzo,5313
 voiceio/feedback.py,sha256=i1Hkd_bydOOQ8p19Bz4bYougjQtozKGLjfKc5DKRDT0,5711
-voiceio/health.py,sha256=r0nMDozuhk1nZNpCiVhmezC_7P6ElQpaBB_IomzmXF8,22166
+voiceio/health.py,sha256=PuOQ1DOtoLUbx-tU0vXRUKe_mdsgVi5up0r1jDLvCnk,22267
 voiceio/hints.py,sha256=dmoiMAJ0YGTWwFc9kIPvEs_BQJN7UEUiwYuLUD_GoQQ,1415
 voiceio/history.py,sha256=cD3Ysa39qt6uKbrcLeRQt-FOJcYCoqie4UNsUWF7DuM,5763
 voiceio/llm.py,sha256=cO2RHM2zHxTD4r5mFFNatB-pjOSl29Wx_I00f7ywYCw,9161
 voiceio/llm_api.py,sha256=4jJ5U1Dop-3uoM9RM3bjUMxB4kYNNjwKbOwIIj0ll3U,9390
 voiceio/numbers.py,sha256=CXJtlMhmV6_9Z1FtKAF4-RXycw8voV-BYHPBpdw1I6Y,13571
-voiceio/pidlock.py,sha256=RInlF_8H7wR0nqkdlhUfxYs7OGzHIvb5p-XDjjQSTNg,619
+voiceio/pidlock.py,sha256=OZLNskUyv9_F3WgyHZWw8WmKt0W7ioxH6xgHitOwCww,1216
 voiceio/platform.py,sha256=uG_5KeYey_29GCn4nSOQJ1UpoCrBC_m2DR7IeoRnuL4,19142
 voiceio/postcorrect.py,sha256=JN5l9xnyGfYq2_owSUwkJ513QiQQKxCrT3hjU5aJCpg,17322
 voiceio/postprocess.py,sha256=rzKmf_ZCskhGnqLEbHaiQX-Sz9yutdJwcwposz7GJ4Q,4661
@@ -26,7 +26,7 @@ voiceio/privacy.py,sha256=FqnA9jx9RCqWW-i6Dh7JcT7vzz97kbUGyQEvsHLvpqc,573
 voiceio/prompt.py,sha256=9iza8KoQxvO_U9NPMJ8Ep7j-zkIs9nW8N5sacCRpsEk,2904
 voiceio/recorder.py,sha256=k51Py6av0YFkc1ENXsrXuFIL3G9bmsAijGq3X5r7pG4,15734
 voiceio/retention.py,sha256=TH_D29EUYyzEPl5FK0q32mpsSk0-0bx56JwAH83FBHI,6272
-voiceio/service.py,sha256=_cTb1AQ57cF8-eW3SKvDkCP46S5yJqhty1fe_eI8zbQ,14324
+voiceio/service.py,sha256=N4idcPlDaarLXEMMts69Viqro5VJqmHywXmqr99UGA4,14915
 voiceio/streaming.py,sha256=hKak7ULkZbkHl5Fw0SnnZsEK3alv2s8dcuCcyBzpIQY,24700
 voiceio/suggest.py,sha256=jX4bCpnddyrteKfRBPbnUgf-Rk5145LFaSTat0_Ll2E,4836
 voiceio/tokens.py,sha256=m5tusR3zEBX7fRKaDUj4z-DSv8NcMhE-02HviAziENQ,5710
@@ -41,9 +41,9 @@ voiceio/cli/configcmd.py,sha256=YF7t-LkwEYEGH4qcO86xehWVX0LvltqxjDFpMF5ljjA,2858
 voiceio/cli/corrections.py,sha256=OBjgiOhtWlTQpQq0HLAvk5-EfKJ7NNt-hnNBHm7obEc,4247
 voiceio/cli/doctor.py,sha256=P8bOn4xedMistlKHhNeeGxRsmogV6jBVKc-CUbo0LXs,7769
 voiceio/cli/history.py,sha256=IWyFIozX5PUwtrU17JlkNea9nP_oKLsXfkxIVHjkfD0,1516
-voiceio/cli/learn.py,sha256=cQ3HOf0LXybRf-40QA6Jvb54gy7rpCCz_2xavPJE7wk,24859
+voiceio/cli/learn.py,sha256=U6NKRQKsV6P6wxWr_Lhx_QwVio640nLZ2iggCmqT5Qo,26516
 voiceio/cli/models.py,sha256=fye_mHbsXLY11uRC1BCDlucCHPny9ftoehAeUJPMJv0,4263
-voiceio/cli/servicecmd.py,sha256=hcaQD1NL38fvkrHtId1307MIgyi2O2xBP6YvG8CTngc,4219
+voiceio/cli/servicecmd.py,sha256=2St2WfLkt06EpC51I5i9Ykv_pvLKzu_dz01M-29O3-4,4830
 voiceio/cli/uninstall.py,sha256=Vqnq6-4hjhDrxqkU_1wtXkY5BU_Tqa-TjZA0Qpf12e4,8921
 voiceio/cli/vocab.py,sha256=lxxuSukefvIHV4fFSduCQQewXY0_Bvf5sDnG4bqLWH8,4418
 voiceio/core/__init__.py,sha256=K0b4duczohS3IrIMLp9fYhfb-GeuyQaOVH_8teYGsQM,277
@@ -75,10 +75,10 @@ voiceio/ibus/textlimit.py,sha256=4Hmn2LDEOs7h-Hb2-cT1HkvIRepDgZq4KRI9KD3xiBQ,251
 voiceio/learn/__init__.py,sha256=Q98-C809lkMqTS0OAV1xNVtqHz9NvuekivXiHiVHBWA,750
 voiceio/learn/augment.py,sha256=qyegRlg3cQF5CT0HV85Jm93Jd9xZpjWwbFVk_VzFdiI,4105
 voiceio/learn/clean.py,sha256=1ItIfIAsqxZLZ76T4oF7kSr4Poo-z_6GEzhrlt21uMo,4922
-voiceio/learn/evaluate.py,sha256=_a1sIum_T2f5lEVJ9-4VjgXOwmLh-B8R1PI7C7zmWH8,12600
+voiceio/learn/evaluate.py,sha256=sW2lfV9jK22fpFFgxh9p6cp0pcTt5KjXV3eatsrg9sM,13233
 voiceio/learn/importer.py,sha256=uB-gHWwSewZYTx22j9h941ARtDE8BFHmf8p3HaHUC6g,3544
 voiceio/learn/metrics.py,sha256=b2xWUzPpNpXHn6zgS1upPbEcpW3ExH9SmSLIUzPhStQ,5174
-voiceio/learn/review.py,sha256=p11kRY-PF9YhS7aYjcYpDUJavUn8OXXz4d6S-MGfCGE,4575
+voiceio/learn/review.py,sha256=X5qs5yEf20Ao3gMhsbW3Eur62hSqy9AYlv08Pcrllxo,5572
 voiceio/learn/store.py,sha256=MauWhGaI2drMbiChIZOblpPS_uVAw-1sNWGyGACHYw8,12816
 voiceio/learn/teacher.py,sha256=uF4hQkrdjv012TTBRSwrhQqqAeCFNoidABcrgzSVUoI,3696
 voiceio/learn/train.py,sha256=zTyftCsUV6hYy9WA8ftZtqjVbYJ-C7py0EoxavXWr7I,17628
@@ -125,8 +125,8 @@ voiceio/typers/pynput_type.py,sha256=Rzkixn08iaIqSCZ5vRybaHpn05lkx4FiEa_OakaiM1A
 voiceio/typers/wtype.py,sha256=d1wG-HZdYDQxXIysV_Xvk9HixDpaJgl3VEoKbP5vhIs,1786
 voiceio/typers/xdotool.py,sha256=dh1zhPqUT8ihJahJ7ZKm6PtfYY087UAzADx664DvQOM,1356
 voiceio/typers/ydotool.py,sha256=e19GvDHL9GS-jgh_hzW3PGBFPCc4IJCWsBWEzU_LqGs,5934
-python_voiceio-1.2.0.dist-info/METADATA,sha256=zEVw8vdKC4meGy8FxLLwba5SoZAb3LPu5OfTYlsusYo,21153
-python_voiceio-1.2.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-python_voiceio-1.2.0.dist-info/entry_points.txt,sha256=iDIDmhvQ3xeN_CWsFne1t9STZ08I25I_wp0xmde_vMs,94
-python_voiceio-1.2.0.dist-info/top_level.txt,sha256=piwtn309lD6uexQyXdZ-efAVBJF9y6Wfr48Z-8zkNhg,8
-python_voiceio-1.2.0.dist-info/RECORD,,
+python_voiceio-1.3.0.dist-info/METADATA,sha256=4h8z_g90MVVyjyWYlF4E-eFc8rYEc9ihcdM4gnPqHug,21201
+python_voiceio-1.3.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+python_voiceio-1.3.0.dist-info/entry_points.txt,sha256=iDIDmhvQ3xeN_CWsFne1t9STZ08I25I_wp0xmde_vMs,94
+python_voiceio-1.3.0.dist-info/top_level.txt,sha256=piwtn309lD6uexQyXdZ-efAVBJF9y6Wfr48Z-8zkNhg,8
+python_voiceio-1.3.0.dist-info/RECORD,,

voiceio/__init__.py

@@ -1 +1 @@
-__version__ = "1.2.0"
+__version__ = "1.3.0"

voiceio/app.py

@@ -43,6 +43,10 @@ class VoiceIO:
     @_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)
@@ -660,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)
@@ -669,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()
 

voiceio/cli/learn.py

@@ -84,10 +84,14 @@ def register(sub: argparse._SubParsersAction) -> None:
                     help="new labeled clips needed before retraining (default 50)")
     mt.add_argument("--base", default="small")
     mt.add_argument("--epochs", type=int, default=4)
+    mt.add_argument("--auto-promote", action="store_true",
+                    help="switch to the fine-tune when it wins, and restart the daemon")
     mt.set_defaults(func=cmd_maintain)
 
     sc = lsub.add_parser("schedule", help="Run `maintain` every night (systemd timer)")
     sc.add_argument("state", nargs="?", choices=("on", "off"), help="omit to show")
+    sc.add_argument("--auto-promote", action="store_true",
+                    help="with on: switch to a fine-tune that wins, without asking")
     sc.set_defaults(func=cmd_schedule)
 
     pr = lsub.add_parser("promote", help="Use a trained model for dictation")
@@ -182,8 +186,7 @@ def cmd_status(args: argparse.Namespace) -> None:
         print(f"models     {', '.join(runs)}")
     active = _cfg().model.name
     print(f"active     {active}")
-    from voiceio import service
-    print(f"nightly    {'on' if service.learn_timer_enabled() else 'off (voiceio learn schedule on)'}")
+    print(f"nightly    {_schedule_state()}")
     promotable = _print_scores(ds, active, runs) if ds else None
     if promotable:
         nxt = f"promote {promotable}"
@@ -197,9 +200,9 @@ def _print_scores(ds: Path, active: str, runs: list[str]) -> str | None:
     """Scores on `ds` for the active model and each fine-tune; returns the
     run that beats the active model on everything, if any."""
     from voiceio.learn import evaluate
-    current = evaluate.latest(active, ds.name)
+    current = evaluate.latest(active, ds.name, beam=_cfg().model.beam_size)
     rows = [(active + " (active)", current)] + [
-        (run, evaluate.latest(str(_models_dir() / run / "ct2"), ds.name)) for run in runs]
+        (run, evaluate.latest(str(_models_dir() / run / "ct2"), ds.name, beam=_cfg().model.beam_size)) for run in runs]
     if not any(r for _, r in rows):
         return None
     print(f"\nscores on {ds.name} test clips:")
@@ -442,8 +445,9 @@ def cmd_maintain(args: argparse.Namespace) -> None:
     labeled = {c.audio for c in store.clips() if c.audio in labels}
     ds = store.latest_dataset()
     new = len(labeled - store.dataset_clips(ds)) if ds else len(labeled)
-    if ds is not None and new < args.min_new:
-        print(f"{new} new labeled clips since {ds.name}; retraining waits for {args.min_new}.")
+    if new < args.min_new:   # the first dataset too: a handful of clips trains nothing
+        since = f" since {ds.name}" if ds else ""
+        print(f"{new} new labeled clips{since}; retraining waits for {args.min_new}.")
         return
     ds = store.build_dataset()
     print(f"built {ds.name} ({new} new clips)")
@@ -454,13 +458,39 @@ def cmd_maintain(args: argparse.Namespace) -> None:
     print(f"\n{_cfg().model.name} → {run.name} on {ds.name}:\n{table}")
     print(f"better or equal on everything — `voiceio learn promote {run.name}`" if ok
           else "not better on everything — keeping the current model")
-    if ok:   # often runs unattended at night: say so where it will be seen
-        from voiceio import feedback
+    if not ok:
+        return
+    # Often runs unattended at night: say so where it will be seen.
+    from voiceio import feedback
+    if getattr(args, "auto_promote", False):
+        try:
+            cmd_promote(argparse.Namespace(run=run.name, force=False))
+        except SystemExit as refused:   # the gate's own re-check said no
+            print(f"not promoted: {refused}")
+            return
+        from voiceio import service
+        if service.is_installed() and not service.restart_when_idle():
+            feedback.notify("VoiceIO: a better model is ready",
+                            f"Switched to {run.name}; restart voiceio to use it "
+                            "(a dictation was in progress). Undo: voiceio learn rollback",
+                            urgent=True)
+            return
+        feedback.notify("VoiceIO: switched to a better model",
+                        f"Trained on your dictation: {run.name}. Undo: voiceio learn rollback",
+                        urgent=True)
+    else:
         feedback.notify("VoiceIO: a better model is ready",
                         f"Trained on your dictation. Use it: voiceio learn promote {run.name}",
                         urgent=True)
 
 
+def _schedule_state() -> str:
+    from voiceio import service
+    if not service.learn_timer_enabled():
+        return "off (voiceio learn schedule on)"
+    return "on (auto-promote)" if service.learn_timer_auto_promotes() else "on"
+
+
 def cmd_schedule(args: argparse.Namespace) -> None:
     from voiceio import config, service
     if args.state == "on":
@@ -471,16 +501,18 @@ def cmd_schedule(args: argparse.Namespace) -> None:
         if missing := train.missing_train_deps():
             print(f"note: until {', '.join(missing)} are installed it only labels new clips;\n"
                   f"      to also retrain: {train.TRAIN_HINT}")
-        if not service.install_learn_timer():
+        if not service.install_learn_timer(auto_promote=args.auto_promote):
             raise SystemExit("could not enable the timer (needs systemd --user)")
         print("on: every night ~03:30, `voiceio learn maintain` labels new dictation at idle "
-              "priority, retrains once 50+ clips are new, and tells you if the result is better. "
-              "It never switches models by itself.")
+              "priority, retrains once 50+ clips are new, and "
+              + ("switches to the result when it wins on your held-out clips "
+                 "(undo: voiceio learn rollback)." if args.auto_promote else
+                 "tells you if the result is better. It never switches models by itself."))
     elif args.state == "off":
         service.uninstall_learn_timer()
         print("off")
     else:
-        print("on" if service.learn_timer_enabled() else "off — enable: voiceio learn schedule on")
+        print(_schedule_state())
 
 
 def _scores(result) -> dict:
@@ -506,16 +538,16 @@ def _check_beats_current(ct2: Path) -> None:
     """Refuse a promotion the evals don't support (a fine-tune can regress)."""
     from voiceio.learn import evaluate
     ds = store.latest_dataset()
-    current = _cfg().model.name
+    current, beam = _cfg().model.name, _cfg().model.beam_size
     if ds is None:
         raise SystemExit("no dataset to compare on — `voiceio learn build`, or --force")
-    missing = [m for m in (current, str(ct2)) if evaluate.latest(m, ds.name) is None]
+    missing = [m for m in (current, str(ct2)) if evaluate.latest(m, ds.name, beam=beam) is None]
     if missing:
         raise SystemExit("evaluate both models on the same clips first:\n"
                          + "".join(f"  voiceio learn eval --model {m}\n" for m in missing)
                          + "(or promote anyway with --force)")
-    ok, table = evaluate.promotion_verdict(evaluate.latest(str(ct2), ds.name),
-                                           evaluate.latest(current, ds.name))
+    ok, table = evaluate.promotion_verdict(evaluate.latest(str(ct2), ds.name, beam=beam),
+                                           evaluate.latest(current, ds.name, beam=beam))
     print(f"on {ds.name} test clips, {current} → fine-tune:\n{table}")
     if not ok:
         raise SystemExit("the fine-tune is worse on something — not promoting (--force overrides)")

voiceio/cli/servicecmd.py

@@ -85,23 +85,35 @@ def _cmd_service(args: argparse.Namespace) -> None:
             pass
 
 
-def wait_until_idle(timeout: float = 300.0, poll: float = 0.25) -> bool:
+def wait_until_idle(timeout: float = 300.0, poll: float = 0.25,
+                    finalizing_timeout: float = 60.0) -> bool:
     """Wait for the daemon to finish any dictation in progress (stopping it
-    mid-recording loses what was said). True once idle or not running."""
+    mid-recording loses what was said). True once idle or not running; False
+    when it stayed busy. A decode stuck finalizing gets a shorter wait: a
+    restart is how that is recovered."""
     import time
 
-    from voiceio.config import STATE_PATH
-    deadline, told = time.monotonic() + timeout, False
-    while time.monotonic() < deadline:
-        try:
-            state = STATE_PATH.read_text().strip()
-        except OSError:
-            return True          # not running (or pre-1.1): nothing to wait for
-        if state in ("idle", "error"):
-            return True
-        if not told:
-            print(f"Waiting for the dictation in progress to finish ({state})…", flush=True)
-            told = True
-        time.sleep(poll)
-    print("Still busy; going ahead. (--now skips the wait.)", file=sys.stderr)
-    return False
+    from voiceio.config import PID_PATH, STATE_PATH
+    from voiceio.pidlock import daemon_alive
+    start, told = time.monotonic(), False
+    try:
+        while True:
+            if not daemon_alive(PID_PATH):
+                return True      # crashed or stopped: its state file is stale
+            try:
+                state = STATE_PATH.read_text().strip()
+            except OSError:
+                return True      # pre-1.1 daemon: nothing to wait for
+            if state in ("idle", "error"):
+                return True
+            waited = time.monotonic() - start
+            if waited > (finalizing_timeout if state == "finalizing" else timeout):
+                print(f"Still {state}; going ahead. (--now skips the wait.)", file=sys.stderr)
+                return False
+            if not told:
+                print(f"Waiting for the dictation in progress to finish ({state})…", flush=True)
+                told = True
+            time.sleep(poll)
+    except KeyboardInterrupt:
+        print("\nNot waiting.", file=sys.stderr)
+        sys.exit(130)

voiceio/health.py

@@ -247,7 +247,8 @@ def _learning_status(cfg) -> dict[str, str]:
         out["Recordings"] = f"on ({n} kept to learn from)"
     else:
         out["Recordings"] = "off (nothing to learn from)"
-    out["Nightly learning"] = "on" if service.learn_timer_enabled() else "off"
+    out["Nightly learning"] = ("off" if not service.learn_timer_enabled() else
+                               "on (auto-promote)" if service.learn_timer_auto_promotes() else "on")
     return out
 
 

voiceio/learn/evaluate.py

@@ -156,11 +156,11 @@ def save(result: EvalResult) -> Path:
     return path
 
 
-def latest(model: str, dataset: str, mode: str = "offline") -> dict | None:
-    """The newest saved run of `model` (a faster-whisper name or path) on
-    `dataset` scored by the current metrics, or None."""
+def latest(model: str, dataset: str, mode: str = "offline", beam: int = 5) -> dict | None:
+    """The newest saved run of `model` (a faster-whisper name or path) at
+    beam width `beam` on `dataset` scored by the current metrics, or None."""
     runs = learn_dir() / "runs"
-    want = f"faster-whisper:{model}"
+    want = f"faster-whisper:{model}" + (f"@beam{beam}" if beam != 5 else "")
     for path in sorted(runs.glob("eval-*.json"), reverse=True) if runs.exists() else []:
         try:
             data = json.loads(path.read_text())
@@ -173,6 +173,9 @@ def latest(model: str, dataset: str, mode: str = "offline") -> dict | None:
     return None
 
 
+# Fewer held-out clips than this can't tell a better model from luck.
+MIN_EVAL_CLIPS = 5
+
 # A fine-tune may trade a hair of WER for vocabulary; it may not regress either.
 WER_SLACK = 0.002
 
@@ -196,7 +199,10 @@ def paired(candidate: dict, current: dict, *, n_boot: int = 2000) -> dict | None
 
 
 def promotion_verdict(candidate: dict, current: dict) -> tuple[bool, str]:
-    """Is `candidate` at least as good as `current` on the same clips?"""
+    """Is `candidate` at least as good as `current` on the same clips?
+
+    No verdict without evidence: too few clips, different clips, or a clip
+    the candidate failed to decode at all (a crashed decode scores 0% WER)."""
     rows = [("WER", current["wer"], candidate["wer"], "{:.1%}"),
             ("vocab recall", current["term_recall"], candidate["term_recall"], "{:.1%}"),
             ("loops", current["repetitions"], candidate["repetitions"], "{}")]
@@ -208,6 +214,10 @@ def promotion_verdict(candidate: dict, current: dict) -> tuple[bool, str]:
                   f"WER change {p['mean']:+.1%} (90% interval {p['lo']:+.1%} … {p['hi']:+.1%})")
         if p["lo"] < 0 < p["hi"]:
             table += "\n  (the interval spans zero: the WER difference may be luck)"
+    clips = candidate.get("clips", 0)
+    if candidate.get("failures", 0) or clips != current.get("clips", 0) or clips < MIN_EVAL_CLIPS:
+        return False, table + (f"\n  not enough evidence: {clips} clips "
+                               f"({candidate.get('failures', 0)} failed) vs {current.get('clips', 0)}")
     ok = (candidate["wer"] <= current["wer"] + WER_SLACK
           and candidate["term_recall"] >= current["term_recall"]
           and candidate["repetitions"] <= current["repetitions"])

voiceio/learn/review.py

@@ -26,8 +26,10 @@ class Item:
     reason: str
 
 
-def _contains(seg_words: list[str], live_words: list[str]) -> bool:
-    """Whether the segment's words occur (nearly) contiguously in the live text."""
+def _contains(seg_words: list[str], live_words: list[str],
+              tolerance: float = _DISAGREE_WER) -> bool:
+    """Whether the segment's words occur (nearly, within `tolerance` of its
+    words) contiguously in the live text."""
     n = len(seg_words)
     if not n:
         return True
@@ -36,7 +38,7 @@ def _contains(seg_words: list[str], live_words: list[str]) -> bool:
         window = live_words[i:i + n]
         match = sum(a == b for a, b in zip(seg_words, window)) / n
         best = max(best, match)
-        if best >= 1 - _DISAGREE_WER:
+        if best >= 1 - tolerance:
             return True
     return False
 
@@ -84,12 +86,31 @@ def live_span(segment_text: str, live: str) -> str | None:
 
 
 def queue_all(clips: list[Clip], labels: dict[str, Label]) -> list[Item]:
-    """Every segment of every unreviewed clip — for building a gold test set,
-    where a reference is only trustworthy if all of it was checked."""
-    return [Item(clip, labels[clip.audio], i, "test set")
-            for clip in clips
-            if clip.audio in labels and not labels[clip.audio].reviewed
-            for i in range(len(labels[clip.audio].segments))]
+    """Segments to check for a gold test set, cheapest clips first.
+
+    A reference is only trustworthy if all of it was checked — but where the
+    teacher and the live decode agree word for word, two independent models
+    already did; those segments are kept as they are, and only the rest are
+    asked. Clips needing the fewest answers come first, so each minute of
+    review completes as many gold clips as possible. A clip with no live
+    decode (an import) has every segment asked; one where everything agrees
+    asks nothing and stays a teacher label.
+    """
+    per_clip: list[list[Item]] = []
+    for clip in clips:
+        lab = labels.get(clip.audio)
+        if lab is None or lab.reviewed:
+            continue
+        live = metrics.words(clip.raw)
+        items = [Item(clip, lab, i, "test set: teacher and live disagree" if live else "test set")
+                 for i, seg in enumerate(lab.segments)
+                 # Word for word: a gold reference can't skip "kalchi" vs
+                 # "Kalshi" in an otherwise matching sentence.
+                 if not live or not _contains(metrics.words(seg.text), live, tolerance=0.0)]
+        if items:
+            per_clip.append(items)
+    per_clip.sort(key=len)
+    return [it for items in per_clip for it in items]
 
 
 def run(items: list[Item], *, ask: Callable[[Item], str | None],

voiceio/pidlock.py

@@ -20,3 +20,21 @@ def lock_pid_file(fd) -> None:
         import fcntl
         fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
         log.debug("PID lock acquired (fcntl)")
+
+
+def daemon_alive(path) -> bool:
+    """Whether a voiceio daemon holds the PID lock at `path` (probes without
+    keeping the lock, and without truncating the file)."""
+    if sys.platform == "win32":
+        return True     # no cheap probe; callers then trust their other signal
+    import fcntl
+    try:
+        with open(path, "a") as fd:
+            try:
+                fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
+            except BlockingIOError:
+                return True
+            fcntl.flock(fd, fcntl.LOCK_UN)
+            return False
+    except OSError:
+        return False

voiceio/service.py

@@ -86,8 +86,9 @@ WantedBy=graphical-session.target
 """
 
 
-def _learn_units(bin_path: str) -> tuple[str, str]:
+def _learn_units(bin_path: str, auto_promote: bool = False) -> tuple[str, str]:
     """(service, timer) for nightly learning on this machine."""
+    flags = " --auto-promote" if auto_promote else ""
     service = f"""\
 [Unit]
 Description=VoiceIO - learn from today's dictation (label, retrain when enough is new)
@@ -95,7 +96,7 @@ Documentation=https://github.com/Hugo0/voiceio#make-it-yours
 
 [Service]
 Type=oneshot
-ExecStart={bin_path} learn maintain
+ExecStart={bin_path} learn maintain{flags}
 # Background work: it gets the CPU only when nothing else wants it, so
 # dictation and everything else stay fast. The unit's own cgroup already
 # does what `learn` would otherwise re-exec into a scope for.
@@ -128,11 +129,11 @@ def _systemctl(*args: str) -> bool:
         return False
 
 
-def install_learn_timer() -> bool:
+def install_learn_timer(auto_promote: bool = False) -> bool:
     """Run `voiceio learn maintain` nightly. True when the timer is enabled."""
     if _IS_WINDOWS or not has_systemd():
         return False
-    service, timer = _learn_units(_find_voiceio_bin())
+    service, timer = _learn_units(_find_voiceio_bin(), auto_promote)
     SERVICE_DIR.mkdir(parents=True, exist_ok=True)
     LEARN_SERVICE_PATH.write_text(service)
     LEARN_TIMER_PATH.write_text(timer)
@@ -151,6 +152,20 @@ def learn_timer_enabled() -> bool:
     return LEARN_TIMER_PATH.exists() and _systemctl("is-enabled", "--quiet", LEARN_TIMER_NAME)
 
 
+def learn_timer_auto_promotes() -> bool:
+    try:
+        return "--auto-promote" in LEARN_SERVICE_PATH.read_text()
+    except OSError:
+        return False
+
+
+def restart_when_idle() -> bool:
+    """Restart the daemon once no dictation is in progress. False when it
+    stayed busy (never cut a dictation off) or the restart failed."""
+    from voiceio.cli.servicecmd import wait_until_idle
+    return wait_until_idle() and _systemctl("restart", SERVICE_NAME)
+
+
 def uninstall_correct_timer() -> None:
     """Remove the pre-1.0 weekly cloud-mining timer (`correct --auto --batch`).
     It is gone in 1.0: mining moved to the local, opt-in `voiceio learn`."""