python-voiceio 0.8.3__tar.gz → 0.9.0__tar.gz

{python_voiceio-0.8.3/python_voiceio.egg-info → python_voiceio-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-voiceio
-Version: 0.8.3
+Version: 0.9.0
 Summary: Voice dictation for Linux. Speak → text, locally, instantly.
 Author: Hugo Montenegro
 License-Expression: MIT

{python_voiceio-0.8.3 → python_voiceio-0.9.0}/pyproject.toml

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

{python_voiceio-0.8.3 → python_voiceio-0.9.0/python_voiceio.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-voiceio
-Version: 0.8.3
+Version: 0.9.0
 Summary: Voice dictation for Linux. Speak → text, locally, instantly.
 Author: Hugo Montenegro
 License-Expression: MIT

{python_voiceio-0.8.3 → python_voiceio-0.9.0}/python_voiceio.egg-info/SOURCES.txt

@@ -21,6 +21,7 @@ tests/test_concurrency_lockdown.py
 tests/test_config.py
 tests/test_correct_batch.py
 tests/test_corrections.py
+tests/test_evaluate.py
 tests/test_fallback.py
 tests/test_health.py
 tests/test_hints.py
@@ -63,6 +64,7 @@ voiceio/config.py
 voiceio/consent.py
 voiceio/corrections.py
 voiceio/demo.py
+voiceio/evaluate.py
 voiceio/feedback.py
 voiceio/health.py
 voiceio/hints.py

{python_voiceio-0.8.3 → python_voiceio-0.9.0}/tests/test_adjudicate.py

@@ -212,6 +212,17 @@ def _suspicious():
 
 
 class TestBatchFlow:
+    """The adjudication flow. Correction mining is retired by default
+    ([autocorrect] mine_corrections = false, see test_correct_batch.py), so
+    these opt it back in — the machinery still has to be correct for anyone who
+    turns it on, and for the vocabulary path that shares it."""
+
+    def _cfg(self):
+        from voiceio.config import load
+        cfg = load()
+        cfg.autocorrect.mine_corrections = True
+        return cfg
+
     def _run(self, tmp_path, adj, *, review=None, suspicious=None, notify=None):
         from voiceio.autocorrect import ReviewResult
         cd = CorrectionDict(path=tmp_path / "c.json")
@@ -219,7 +230,8 @@ class TestBatchFlow:
             ask_user=[{"wrong": "mantekka", "right": "", "reason": "?"}],
         )
         suspicious = suspicious if suspicious is not None else _suspicious()
-        with patch("voiceio.llm_api.resolve_api_key", return_value="sk-x"), \
+        with patch("voiceio.config.load", return_value=self._cfg()), \
+             patch("voiceio.llm_api.resolve_api_key", return_value="sk-x"), \
              patch("voiceio.history.read", return_value=_entries()), \
              patch("voiceio.autocorrect.find_suspicious_words",
                    return_value=suspicious), \
@@ -274,6 +286,7 @@ class TestBatchFlow:
 
         cd = CorrectionDict(path=tmp_path / "c.json")
         with caplog.at_level(logging.INFO, logger="voiceio.cli"), \
+             patch("voiceio.config.load", return_value=self._cfg()), \
              patch("voiceio.llm_api.resolve_api_key", return_value="sk-x"), \
              patch("voiceio.history.read", return_value=_entries()), \
              patch("voiceio.autocorrect.find_suspicious_words", return_value=many), \

{python_voiceio-0.8.3 → python_voiceio-0.9.0}/tests/test_correct_batch.py

@@ -20,6 +20,14 @@ def _suspicious():
                            contexts=["check the mantekka transfers"])]
 
 
+def _cfg_with_mining():
+    """Config with the retired correction mining explicitly opted back in."""
+    from voiceio.config import load
+    cfg = load()
+    cfg.autocorrect.mine_corrections = True
+    return cfg
+
+
 class TestBatchMode:
     def test_no_api_key_bails_quietly(self, tmp_path, capsys):
         cd = CorrectionDict(path=tmp_path / "c.json")
@@ -29,7 +37,11 @@ class TestBatchMode:
         assert "skipping batch" in capsys.readouterr().out.lower()
 
     def test_ambiguous_item_deferred_no_notify_cursor_advances(self, tmp_path):
-        """No consensus → silently deferred; no queue, no notification, cursor advances."""
+        """No consensus → silently deferred; no queue, no notification, cursor advances.
+
+        Opts mining back in: it's retired by default (see
+        TestCorrectionMiningRetired) but the machinery must still be correct.
+        """
         cd = CorrectionDict(path=tmp_path / "c.json")
         review = ReviewResult()
         review.ask_user.append({"wrong": "mantekka", "right": "Manteca",
@@ -37,7 +49,8 @@ class TestBatchMode:
         adj = AdjudicationResult(
             deferred=[{"wrong": "mantekka", "right": "Manteca", "votes": []}],
         )
-        with patch("voiceio.llm_api.resolve_api_key", return_value="sk-x"), \
+        with patch("voiceio.config.load", return_value=_cfg_with_mining()), \
+             patch("voiceio.llm_api.resolve_api_key", return_value="sk-x"), \
              patch("voiceio.history.read", return_value=_entries()), \
              patch("voiceio.autocorrect.find_suspicious_words",
                    return_value=_suspicious()), \
@@ -54,11 +67,13 @@ class TestBatchMode:
         assert "mantekka" in state.deferred
 
     def test_unanimous_correction_applied_and_notified(self, tmp_path):
+        """Mining opted back in — it's retired by default, not deleted."""
         cd = CorrectionDict(path=tmp_path / "c.json")
         review = ReviewResult()
         review.ask_user.append({"wrong": "mantekka", "right": "", "reason": "?"})
         adj = AdjudicationResult(apply=[{"wrong": "mantekka", "right": "manteca"}])
-        with patch("voiceio.llm_api.resolve_api_key", return_value="sk-x"), \
+        with patch("voiceio.config.load", return_value=_cfg_with_mining()), \
+             patch("voiceio.llm_api.resolve_api_key", return_value="sk-x"), \
              patch("voiceio.history.read", return_value=_entries()), \
              patch("voiceio.autocorrect.find_suspicious_words",
                    return_value=_suspicious()), \
@@ -127,3 +142,70 @@ class TestProtectLanguages:
         assert gate_correction("ngroc", "ngrok",
                                vocabulary={"ngrok"},
                                protect_languages=["es", "ca"]) is None
+
+
+class TestCorrectionMiningRetired:
+    """Correction mining is off by default.
+
+    Measured over months: 387 rules mined, 4 ever fired (1%), while the runtime
+    postcorrect pass applied 288 edits. Rules are exact-string matches, so they
+    only fire if Whisper repeats a misrecognition verbatim — and the errors
+    worth fixing ("nuance" for "neurons") are common words the safety gate must
+    refuse. One run learned rules that destroyed real Spanish words. Vocabulary
+    mining is a different story and stays on.
+    """
+
+    def _review(self):
+        # "compain" -> "company" passes gate_correction: the target is a common
+        # word. ("olamma" -> "Ollama" would be rejected because the target is
+        # neither common nor already in the vocabulary — pre-existing gate
+        # behaviour, unrelated to mining being retired.)
+        from voiceio.autocorrect import ReviewResult
+        return ReviewResult(
+            auto_fix=[{"wrong": "compain", "right": "company", "reason": "typo"}],
+            ask_user=[{"wrong": "wordal", "right": "Wordle", "reason": "maybe"}],
+            vocabulary=["Kubernetes"],
+        )
+
+    def test_default_is_off(self):
+        from voiceio.config import AutocorrectConfig
+        assert AutocorrectConfig().mine_corrections is False
+
+    def test_no_rules_learned_by_default(self):
+        """The whole point: a batch run must not grow corrections.json."""
+        from voiceio.corrections import CorrectionDict
+
+        cd = CorrectionDict()
+        with patch("voiceio.llm_api.resolve_api_key", return_value="sk-x"), \
+             patch("voiceio.history.read", return_value=_entries()), \
+             patch("voiceio.autocorrect.find_suspicious_words", return_value=_suspicious()), \
+             patch("voiceio.autocorrect.review_suspicious", return_value=self._review()), \
+             patch("voiceio.autocorrect.adjudicate") as adj, \
+             patch("voiceio.vocabulary.add_terms", return_value=1) as add_terms, \
+             patch("voiceio.feedback.notify"):
+            _cmd_correct_auto(cd, batch=True)
+
+        assert cd.list_all() == {}       # no rules learned
+        assert not adj.called            # and no LLM spend adjudicating them
+        assert add_terms.called          # vocabulary mining still runs
+
+    def test_opt_in_still_mines(self):
+        """The machinery is retired, not deleted — it must still work if asked."""
+        from voiceio.autocorrect import AdjudicationResult
+        from voiceio.corrections import CorrectionDict
+
+        cfg = _cfg_with_mining()
+        cd = CorrectionDict()
+        adj = AdjudicationResult(apply=[], vocabulary=[], deferred=[])
+        with patch("voiceio.config.load", return_value=cfg), \
+             patch("voiceio.llm_api.resolve_api_key", return_value="sk-x"), \
+             patch("voiceio.history.read", return_value=_entries()), \
+             patch("voiceio.autocorrect.find_suspicious_words", return_value=_suspicious()), \
+             patch("voiceio.autocorrect.review_suspicious", return_value=self._review()), \
+             patch("voiceio.autocorrect.adjudicate", return_value=adj) as adjudicate, \
+             patch("voiceio.vocabulary.add_terms", return_value=1), \
+             patch("voiceio.feedback.notify"):
+            _cmd_correct_auto(cd, batch=True)
+
+        assert "compain" in cd.list_all()  # gate-passing auto_fix applied
+        assert adjudicate.called           # ambiguous ones still adjudicated

python_voiceio-0.9.0/tests/test_evaluate.py

@@ -0,0 +1,198 @@
+"""Tests for the decoder-config eval harness.
+
+The harness exists because every decoder knob was set from a plausible story and
+one example. Its own detectors must not be in the same position — hence real
+assertions on the hallucination/repetition counters, using the exact shapes seen
+in production.
+"""
+from __future__ import annotations
+
+import wave
+from unittest.mock import patch
+
+import numpy as np
+
+from voiceio.evaluate import (
+    count_hallucinations,
+    count_repetitions,
+    default_matrix,
+    evaluate,
+    sample_clips,
+)
+
+
+class TestHallucinationDetection:
+    def test_catches_whisper_filler(self):
+        assert count_hallucinations([" Thank you."]) == 1
+        assert count_hallucinations(["Thanks for watching!"]) == 1
+        assert count_hallucinations([" Thank you.", " Thank you."]) == 2
+
+    def test_ignores_real_speech(self):
+        assert count_hallucinations(["Thank you for the detailed review"]) == 0
+        assert count_hallucinations(["so I want you to own this end to end"]) == 0
+
+    def test_matches_whole_segment_not_substring(self):
+        """'thank you' inside a sentence is speech, not a hallucination."""
+        assert count_hallucinations(["I say thank you to the team"]) == 0
+
+    def test_empty(self):
+        assert count_hallucinations([]) == 0
+        assert count_hallucinations(["", "   "]) == 0
+
+
+class TestRepetitionDetection:
+    def test_catches_the_real_loop(self):
+        """Verbatim from a 422s dictation that looped four times."""
+        text = ("make a hypothesis why intelligence is not working out "
+                + "because it should not work out in the complex world " * 4
+                + "so we have seen simpler simulations")
+        assert count_repetitions(text) >= 1
+
+    def test_ignores_normal_speech(self):
+        text = ("So on each generation we have an algorithm to determine the "
+                "general shape of the brain and once that is determined we add "
+                "one or two nodes or more hidden nodes and more connections")
+        assert count_repetitions(text) == 0
+
+    def test_ignores_short_text(self):
+        assert count_repetitions("testing testing one two three") == 0
+
+    def test_needs_a_real_run_not_two(self):
+        """Saying something twice is emphasis; three-plus is a decode loop."""
+        twice = "the quick brown fox the quick brown fox and then it stopped"
+        assert count_repetitions(twice) == 0
+
+
+class TestDefaultMatrix:
+    def test_includes_shipped_baseline(self):
+        names = [c.name for c in default_matrix()]
+        assert "shipped" in names
+
+    def test_shipped_matches_the_worker(self):
+        """If worker.py's decode params drift, this baseline is a lie."""
+        shipped = next(c for c in default_matrix() if c.name == "shipped")
+        src = (__import__("pathlib").Path(__file__).resolve().parent.parent
+               / "voiceio" / "worker.py").read_text()
+        assert "condition_on_previous_text=False" in src
+        assert "vad_filter=True" in src
+        assert shipped.condition_on_previous_text is False
+        assert shipped.vad_filter is True
+
+    def test_never_pairs_cond_with_hotwords(self):
+        """They share faster-whisper's sot_prev slot: 223 + 223 + sot > 448,
+        which raises 'maximum decoding length must be > 0'. Not a config."""
+        for c in default_matrix():
+            assert not (c.condition_on_previous_text and c.hotwords), c.name
+
+
+def _write_wav(path, secs=1.0):
+    with wave.open(str(path), "wb") as w:
+        w.setnchannels(1)
+        w.setsampwidth(2)
+        w.setframerate(16000)
+        w.writeframes((np.zeros(int(16000 * secs), dtype=np.int16)).tobytes())
+
+
+class TestSampleClips:
+    def test_respects_audio_budget(self, tmp_path, monkeypatch):
+        rec = tmp_path / "recordings"
+        rec.mkdir()
+        for i in range(10):
+            _write_wav(rec / f"c{i}.wav", secs=2.0)
+        monkeypatch.setattr("voiceio.config.RECORDINGS_DIR", rec)
+        got = sample_clips(5.0)
+        assert 0 < len(got) <= 3  # 2s each, budget 5s
+
+    def test_no_recordings_dir(self, tmp_path, monkeypatch):
+        monkeypatch.setattr("voiceio.config.RECORDINGS_DIR", tmp_path / "nope")
+        assert sample_clips(100) == []
+
+    def test_includes_long_clips(self, tmp_path, monkeypatch):
+        """The bias this replaced: newest-first sampling was ALL short clips
+        (8 clips, 22s avg), so condition_on_previous_text's repetition loops —
+        which only happen on long dictation — could not appear, and the harness
+        happily recommended cond=True."""
+        rec = tmp_path / "recordings"
+        rec.mkdir()
+        for i in range(30):  # many short, newest
+            _write_wav(rec / f"short{i:02d}.wav", secs=10.0)
+        _write_wav(rec / "long.wav", secs=120.0)
+        monkeypatch.setattr("voiceio.config.RECORDINGS_DIR", rec)
+
+        got = sample_clips(300)
+        names = [p.name for p in got]
+        assert "long.wav" in names
+        assert any(n.startswith("short") for n in names)
+
+    def test_all_short_still_fills_budget(self, tmp_path, monkeypatch):
+        """No long recordings must not mean a half-empty sample."""
+        rec = tmp_path / "recordings"
+        rec.mkdir()
+        for i in range(20):
+            _write_wav(rec / f"s{i:02d}.wav", secs=10.0)
+        monkeypatch.setattr("voiceio.config.RECORDINGS_DIR", rec)
+        got = sample_clips(100)
+        assert len(got) >= 9  # ~10 x 10s, not capped at the 50% short share
+
+
+class TestEvaluate:
+    def test_no_audio_returns_empty(self, tmp_path, monkeypatch):
+        monkeypatch.setattr("voiceio.config.RECORDINGS_DIR", tmp_path / "nope")
+        from voiceio.config import Config
+        assert evaluate(Config(), default_matrix(), teacher=lambda p: "x") == []
+
+    def test_teacher_silence_returns_empty(self, tmp_path, monkeypatch):
+        """A teacher that hears nothing gives nothing to score against."""
+        rec = tmp_path / "recordings"
+        rec.mkdir()
+        _write_wav(rec / "a.wav")
+        monkeypatch.setattr("voiceio.config.RECORDINGS_DIR", rec)
+        from voiceio.config import Config
+        assert evaluate(Config(), default_matrix(), teacher=lambda p: "") == []
+
+    def test_scores_and_ranks_by_wer(self, tmp_path, monkeypatch):
+        rec = tmp_path / "recordings"
+        rec.mkdir()
+        _write_wav(rec / "a.wav", secs=1.0)
+        monkeypatch.setattr("voiceio.config.RECORDINGS_DIR", rec)
+
+        class _Seg:
+            def __init__(self, t):
+                self.text = t
+
+        class _Model:
+            def transcribe(self, audio, **kw):
+                # The no-vad config "hears" the reference exactly; shipped drops
+                # a word. Ranking must follow WER, not declaration order.
+                if kw.get("vad_filter"):
+                    return iter([_Seg("hello there")]), None
+                return iter([_Seg("hello there world")]), None
+
+        from voiceio.config import Config
+        with patch("voiceio.worker.load_model", return_value=_Model()), \
+             patch("voiceio.vocabulary.load_terms", return_value=[]):
+            scores = evaluate(Config(), default_matrix(),
+                              teacher=lambda p: "hello there world")
+
+        assert scores
+        assert scores[0].wer <= scores[-1].wer          # sorted best-first
+        assert scores[0].config.vad_filter is False     # the exact-match config
+        assert all(s.clips == 1 for s in scores)
+
+    def test_a_crashing_config_is_a_result_not_an_error(self, tmp_path, monkeypatch):
+        rec = tmp_path / "recordings"
+        rec.mkdir()
+        _write_wav(rec / "a.wav")
+        monkeypatch.setattr("voiceio.config.RECORDINGS_DIR", rec)
+
+        class _Model:
+            def transcribe(self, audio, **kw):
+                raise ValueError("The maximum decoding length must be > 0")
+
+        from voiceio.config import Config
+        with patch("voiceio.worker.load_model", return_value=_Model()), \
+             patch("voiceio.vocabulary.load_terms", return_value=[]):
+            scores = evaluate(Config(), default_matrix(), teacher=lambda p: "hi")
+
+        assert all(s.crashes == 1 for s in scores)
+        assert all(s.clips == 0 for s in scores)

python_voiceio-0.9.0/voiceio/__init__.py

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

{python_voiceio-0.8.3 → python_voiceio-0.9.0}/voiceio/cli.py

@@ -110,6 +110,14 @@ def main() -> None:
     p_history.add_argument("--path", action="store_true",
                            help="Print history file path")
 
+    # ── voiceio eval ───────────────────────────────────────────────────
+    p_eval = sub.add_parser(
+        "eval", help="Replay your retained audio across decoder configs and score them")
+    p_eval.add_argument("--max-audio-secs", type=float, default=900,
+                        help="Audio budget to replay (default: 900 = 15min)")
+    p_eval.add_argument("--json", action="store_true",
+                        help="Emit raw results as JSON")
+
     # ── voiceio demo ──────────────────────────────────────────────────
     sub.add_parser("demo", help="Interactive guided tour of voiceio features")
 
@@ -136,6 +144,8 @@ def main() -> None:
         _cmd_correct(args)
     elif args.command == "history":
         _cmd_history(args)
+    elif args.command == "eval":
+        _cmd_eval(args)
     elif args.command == "demo":
         _cmd_demo()
     elif args.command == "logs":
@@ -720,6 +730,91 @@ def _cmd_uninstall() -> None:
             print("\nvoiceio fully removed.")
 
 
+def _cmd_eval(args: argparse.Namespace) -> None:
+    """Score decoder configs against a teacher model on your own audio."""
+    import json as _json
+    import sys
+    import time
+
+    from voiceio.config import load
+    from voiceio.evaluate import default_matrix, evaluate
+    from voiceio.wizard import BOLD, DIM, GREEN, RESET, YELLOW
+
+    cfg = load()
+    matrix = default_matrix()
+
+    print(f"{BOLD}Evaluating {len(matrix)} decoder configs{RESET} "
+          f"{DIM}on up to {args.max_audio_secs:.0f}s of your retained audio{RESET}")
+    print(f"{DIM}Scored against a teacher model (distil-large-v3) — a proxy for")
+    print(f"ground truth, good for ranking configs, not for absolute accuracy.{RESET}\n")
+
+    last = [""]
+
+    def progress(name, i, n):
+        if name != last[0]:
+            last[0] = name
+            sys.stderr.write(f"\n  {name}: ")
+        sys.stderr.write(".")
+        sys.stderr.flush()
+
+    t0 = time.time()
+    scores = evaluate(cfg, matrix, max_audio_secs=args.max_audio_secs,
+                      on_progress=progress)
+    sys.stderr.write("\n\n")
+
+    if not scores:
+        print("No retained audio to evaluate. Dictate a few notes first "
+              "(audio is kept under [data] retain_audio).")
+        return
+
+    if args.json:
+        print(_json.dumps([{
+            "config": s.config.name, **s.config.as_dict(),
+            "clips": s.clips, "audio_secs": round(s.audio_secs, 1),
+            "wer": s.wer, "hallucinations": s.hallucinations,
+            "repetitions": s.repetitions, "empties": s.empties,
+            "crashes": s.crashes, "decode_secs": round(s.decode_secs, 1),
+        } for s in scores], indent=2))
+        return
+
+    best = scores[0]
+    shipped = next((s for s in scores if s.config.name == "shipped"), None)
+
+    print(f"  {'config':<24} {'WER':>7} {'halluc':>7} {'repeat':>7} "
+          f"{'empty':>6} {'crash':>6}")
+    print(f"  {'-'*24} {'-'*7} {'-'*7} {'-'*7} {'-'*6} {'-'*6}")
+    for s in scores:
+        mark = f" {GREEN}<- best{RESET}" if s is best else ""
+        if s is shipped and s is not best:
+            mark = f" {DIM}<- shipped{RESET}"
+        elif s is shipped:
+            mark = f" {GREEN}<- best (shipped){RESET}"
+        print(f"  {s.config.name:<24} {s.wer:>7.3f} {s.hallucinations:>7} "
+              f"{s.repetitions:>7} {s.empties:>6} {s.crashes:>6}{mark}")
+
+    print(f"\n  {DIM}{best.clips} clips, {best.audio_secs:.0f}s audio, "
+          f"{time.time()-t0:.0f}s total{RESET}")
+
+    if shipped and best is not shipped:
+        delta = (shipped.wer - best.wer) / shipped.wer * 100 if shipped.wer else 0
+        print(f"\n  {YELLOW}'{best.config.name}' beats the shipped config by "
+              f"{delta:.0f}% WER.{RESET}")
+        # A WER win means nothing if it comes from the failure mode the knob
+        # exists to prevent, so make that trade explicit rather than implied.
+        if best.hallucinations > shipped.hallucinations:
+            print(f"  {YELLOW}But it hallucinates more "
+                  f"({best.hallucinations} vs {shipped.hallucinations}) — "
+                  f"that's what vad_filter is for.{RESET}")
+        if best.repetitions > shipped.repetitions:
+            print(f"  {YELLOW}But it loops more "
+                  f"({best.repetitions} vs {shipped.repetitions}) — "
+                  f"that's what condition_on_previous_text=False is for.{RESET}")
+        print(f"  {DIM}The teacher is a proxy, not truth. Spot-check before "
+              f"changing a default.{RESET}")
+    elif shipped:
+        print(f"\n  {GREEN}The shipped config wins. No change indicated.{RESET}")
+
+
 def _show_vocab() -> None:
     """Show the vocabulary split by what actually reaches the decoder.
 
@@ -989,12 +1084,20 @@ def _cmd_correct_auto(cd, *, full: bool = False, batch: bool = False) -> None:
     # Build lookup for O(1) access to suspicious word metadata
     sw_by_word = {sw.word: sw for sw in suspicious}
 
+    # Correction mining is retired by default ([autocorrect] mine_corrections).
+    # The vocabulary bucket below is unaffected: those terms bias the decoder
+    # and measurably help, whereas mined find/replace rules fired 4 times in 387
+    # while postcorrect applied 288 edits over the same span. Skipping the
+    # correction buckets also skips adjudication — the expensive part, at
+    # votes x ceil(N/25) LLM calls per run.
+    mine_corrections = cfg.autocorrect.mine_corrections
+
     # ── Bucket 1: Auto-fix (high confidence, safety-gated) ──────────────
     # Pairs failing the gate (real word being "corrected", or target that is
     # itself junk) are downgraded to manual review rather than persisted.
     auto_fixed = 0
     downgraded: list[dict] = []
-    if result.auto_fix:
+    if result.auto_fix and mine_corrections:
         gated = []
         for fix in result.auto_fix:
             reason = gate_correction(
@@ -1028,10 +1131,13 @@ def _cmd_correct_auto(cd, *, full: bool = False, batch: bool = False) -> None:
         )
 
     # ── Bucket 2: Ask user (ambiguous) ──────────────────────────────────
-    to_review = downgraded + list(result.ask_user)
+    # Empty when correction mining is retired — nothing to adjudicate or review.
+    to_review = (downgraded + list(result.ask_user)) if mine_corrections else []
 
     # If no LLM was used, put all suspicious words into manual review
-    if not has_api and not has_ollama:
+    if not mine_corrections:
+        pass  # correction mining retired — nothing to review or adjudicate
+    elif not has_api and not has_ollama:
         for sw in suspicious:
             to_review.append({
                 "wrong": sw.word,
@@ -1087,8 +1193,13 @@ def _cmd_correct_auto(cd, *, full: bool = False, batch: bool = False) -> None:
         print(f"  {DIM}{len(capped)} lower-frequency item(s) deferred "
               f"to next run{RESET}")
 
-    adj = adjudicate(cfg, to_review, sw_by_word,
-                     vocabulary=vocab_words, language=language)
+    if to_review:
+        adj = adjudicate(cfg, to_review, sw_by_word,
+                         vocabulary=vocab_words, language=language)
+    else:
+        # Nothing to weigh — don't spend votes x ceil(N/25) LLM calls proving it.
+        from voiceio.autocorrect import AdjudicationResult
+        adj = AdjudicationResult()
 
     # Unanimous corrections (already gate-passed inside adjudicate).
     adj_applied = 0

{python_voiceio-0.8.3 → python_voiceio-0.9.0}/voiceio/config.py

@@ -138,6 +138,17 @@ class AutocorrectConfig:
     # Languages you also dictate in: mined corrections never rewrite words
     # that are real in these (e.g. ["es"] protects Spanish "harina").
     protect_languages: list[str] = field(default_factory=list)
+    # Mine find/replace CORRECTION rules from history. Off by default: measured
+    # over months of real use, mining produced 387 rules of which 4 ever fired
+    # (1%), while the runtime postcorrect pass applied 288 edits over the same
+    # period. Rules are exact-string matches, so they only fire when Whisper
+    # repeats a misrecognition verbatim — and the errors worth fixing are
+    # common words ("nuance" for "neurons") that the safety gate must refuse
+    # anyway. Meanwhile a bad rule is a silent regression: one run learned rules
+    # destroying real Spanish words. Poor odds, real downside, and postcorrect
+    # already does this contextually. Vocabulary mining is unaffected and stays
+    # on — those terms bias the decoder and demonstrably help.
+    mine_corrections: bool = False
 
 
 @dataclass