python-voiceio 0.7.0__tar.gz → 0.8.0__tar.gz

{python_voiceio-0.7.0/python_voiceio.egg-info → python_voiceio-0.8.0}/PKG-INFO

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

{python_voiceio-0.7.0 → python_voiceio-0.8.0}/pyproject.toml

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

{python_voiceio-0.7.0 → python_voiceio-0.8.0/python_voiceio.egg-info}/PKG-INFO

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

{python_voiceio-0.7.0 → python_voiceio-0.8.0}/tests/test_app_wiring.py

@@ -260,3 +260,128 @@ class TestClipboardMirror:
             vio._copy_result_async("hello world")
             assert done.wait(timeout=2)
             mock_copy.assert_called_once_with("hello world")
+
+
+class TestEngineLifecycle:
+    """Dormant-engine reaping is normal; recovery must not steal the source."""
+
+    def _vio_ibus(self, proc_poll=-15):
+        vio, mock_typer, _ = _make_vio()
+        mock_typer.name = "ibus"
+        proc = MagicMock()
+        proc.poll.return_value = proc_poll
+        proc.returncode = -15
+        vio._engine_proc = proc
+        return vio, proc
+
+    def test_idle_engine_death_not_recovered(self):
+        """ibus-daemon reaping a dormant engine must NOT trigger the
+        activate/dormant dance (it grabbed the input source every cycle)."""
+        vio, proc = self._vio_ibus(proc_poll=-15)
+        with patch.object(vio, "_ensure_ibus_engine") as ensure, \
+             patch.object(vio, "_health_typer_upkeep"):
+            vio._check_health()
+        ensure.assert_not_called()
+        assert vio._engine_proc is None
+
+    def test_mid_recording_engine_death_recovered(self):
+        from voiceio.app import _State
+        vio, proc = self._vio_ibus(proc_poll=-15)
+        vio._state = _State.RECORDING
+        with patch.object(vio, "_ensure_ibus_engine") as ensure:
+            vio._check_health()
+        ensure.assert_called_once()
+
+    def test_single_missed_ping_tolerated(self):
+        """One missed ping on a loaded system is not a zombie."""
+        vio, proc = self._vio_ibus(proc_poll=None)
+        with patch.object(vio, "_ping_ibus_engine", return_value=False), \
+             patch.object(vio, "_ensure_ibus_engine") as ensure, \
+             patch.object(vio, "_health_typer_upkeep"):
+            vio._check_health()
+        ensure.assert_not_called()
+        proc.kill.assert_not_called()
+        assert vio._engine_ping_fails == 1
+
+    def test_two_missed_pings_restart_zombie(self):
+        vio, proc = self._vio_ibus(proc_poll=None)
+        with patch.object(vio, "_ping_ibus_engine", return_value=False), \
+             patch.object(vio, "_ensure_ibus_engine") as ensure, \
+             patch.object(vio, "_health_typer_upkeep"):
+            vio._check_health()
+            vio._check_health()
+        ensure.assert_called_once()
+        proc.kill.assert_called_once()
+
+    def test_successful_ping_resets_counter(self):
+        vio, proc = self._vio_ibus(proc_poll=None)
+        vio._engine_ping_fails = 1
+        with patch.object(vio, "_ping_ibus_engine", return_value=True), \
+             patch.object(vio, "_ensure_ibus_engine") as ensure, \
+             patch.object(vio, "_health_typer_upkeep"):
+            vio._check_health()
+        ensure.assert_not_called()
+        assert vio._engine_ping_fails == 0
+
+    def test_record_start_respawns_reaped_engine(self):
+        vio, mock_typer, _ = _make_vio()
+        mock_typer.name = "ibus"
+        vio._engine_proc = None  # reaped while dormant
+        spawned = threading.Event()
+        with patch.object(vio, "_ensure_ibus_engine", side_effect=lambda: spawned.set()), \
+             patch.object(vio, "_switch_gnome_input_source"):
+            vio.on_hotkey()  # start recording
+            assert spawned.wait(timeout=2), "engine respawn not triggered"
+        assert vio.recorder.is_recording
+
+
+class TestEngineRelease:
+    """Going dormant must release ibus's GLOBAL engine, not just gsettings."""
+
+    def test_release_sets_user_engine_unconditionally(self):
+        """Release must not query first: a stale reading during the async
+        activation made it skip itself and leave voiceio globally active."""
+        vio, _, _ = _make_vio()
+        vio._prev_ibus_engine = "xkb:us::eng"
+        with patch("voiceio.app.subprocess.run") as run:
+            run.return_value = MagicMock(returncode=0)
+            vio._release_ibus_engine()
+        assert run.call_count == 1
+        assert run.call_args[0][0] == ["ibus", "engine", "xkb:us::eng"]
+
+    def test_fallback_derived_from_sources_when_prev_stale(self):
+        """A stale 'voiceio' prev (inherited from a crashed daemon) must not
+        be restored; derive the user's xkb layout instead."""
+        vio, _, _ = _make_vio()
+        vio._prev_ibus_engine = "voiceio"
+        with patch("voiceio.app.subprocess.run") as run:
+            run.return_value = MagicMock(
+                returncode=0, stdout="[('xkb', 'de'), ('ibus', 'voiceio')]\n",
+            )
+            assert vio._ibus_engine_fallback() == "xkb:de::eng"
+
+    def test_restore_input_source_releases_engine(self):
+        vio, _, _ = _make_vio()
+        vio.platform.is_gnome = True
+        with patch.object(vio, "_set_gnome_input_source_index"), \
+             patch.object(vio, "_release_ibus_engine") as release:
+            vio._restore_input_source()
+        release.assert_called_once()
+
+
+def test_activation_claims_global_engine():
+    """gsettings 'current' is legacy/no-op on newer GNOME — activation must
+    also claim the global engine directly (mirror of the dormant release)."""
+    vio, _, _ = _make_vio()
+    vio.platform.is_gnome = True
+    with patch("voiceio.app.subprocess.run") as run:
+        run.side_effect = [
+            MagicMock(returncode=0, stdout="[('xkb', 'us'), ('ibus', 'voiceio')]\n"),  # sources
+            MagicMock(returncode=0, stdout="0\n"),   # current (prev)
+            MagicMock(returncode=0),                 # gsettings set current
+            MagicMock(returncode=0),                 # ibus engine voiceio
+        ]
+        with patch("time.sleep"):
+            vio._switch_gnome_input_source("voiceio")
+    cmds = [c[0][0] for c in run.call_args_list]
+    assert ["ibus", "engine", "voiceio"] in cmds

{python_voiceio-0.7.0 → python_voiceio-0.8.0}/tests/test_clipboard_read.py

@@ -94,9 +94,9 @@ def test_read_text_no_tools():
 # --- copy_text ---
 
 def test_copy_text_wayland():
-    """Wayland copies via wl-copy with text on stdin."""
+    """Wayland without xclip copies via wl-copy with text on stdin."""
     with patch("voiceio.clipboard_read.detect", return_value=_mock_platform(display_server="wayland")), \
-         patch("shutil.which", return_value="/usr/bin/wl-copy"), \
+         patch("shutil.which", lambda t: "/usr/bin/wl-copy" if t == "wl-copy" else None), \
          patch("subprocess.run") as mock_run:
         mock_run.return_value = MagicMock(returncode=0)
         from voiceio.clipboard_read import copy_text
@@ -143,3 +143,31 @@ def test_copy_text_command_failure():
         mock_run.return_value = MagicMock(returncode=1)
         from voiceio.clipboard_read import copy_text
         assert copy_text("hello") is False
+
+
+def test_copy_text_wayland_prefers_xclip_bridge():
+    """On Wayland prefer xclip (XWayland bridge): wl-copy can steal focus
+    on GNOME, and a focus-out discards a visible IBus preedit."""
+    with patch("voiceio.clipboard_read.detect", return_value=_mock_platform(display_server="wayland")), \
+         patch("shutil.which", lambda t: f"/usr/bin/{t}" if t in ("xclip", "wl-copy") else None), \
+         patch("subprocess.run") as mock_run:
+        mock_run.return_value = MagicMock(returncode=0)
+        from voiceio.clipboard_read import copy_text
+        assert copy_text("hello") is True
+        assert mock_run.call_args[0][0][0] == "xclip"
+
+
+def test_copy_text_wayland_falls_back_to_wl_copy():
+    """xclip failing (no DISPLAY etc.) falls through to wl-copy."""
+    calls = []
+
+    def run(cmd, **kw):
+        calls.append(cmd[0])
+        return MagicMock(returncode=1 if cmd[0] == "xclip" else 0)
+
+    with patch("voiceio.clipboard_read.detect", return_value=_mock_platform(display_server="wayland")), \
+         patch("shutil.which", lambda t: f"/usr/bin/{t}" if t in ("xclip", "wl-copy") else None), \
+         patch("subprocess.run", side_effect=run):
+        from voiceio.clipboard_read import copy_text
+        assert copy_text("hello") is True
+    assert calls == ["xclip", "wl-copy"]

{python_voiceio-0.7.0 → python_voiceio-0.8.0}/tests/test_ibus_typer.py

@@ -103,16 +103,13 @@ class TestIBusTyper:
         typer.delete_chars(10)  # should not raise
 
     def test_commit_copies_to_clipboard(self, mock_socket):
-        """commit_text also copies text to clipboard as backup."""
+        """commit_text also copies text to clipboard as backup (via the
+        focus-safe clipboard_read.copy_text, never wl-copy directly)."""
         typer = IBusTyper()
-        typer._wl_copy = "/usr/bin/wl-copy"
-        mock_proc = MagicMock()
-        mock_proc.stdin = MagicMock()
-        with patch("voiceio.typers.ibus.subprocess.Popen", return_value=mock_proc), \
+        with patch("voiceio.clipboard_read.copy_text", return_value=True) as mock_copy, \
              patch("voiceio.typers.ibus.subprocess.run"):
             typer.commit_text("Hello")
-            mock_proc.stdin.write.assert_called_once_with(b"Hello")
-            mock_proc.stdin.close.assert_called_once()
+            mock_copy.assert_called_once_with("Hello")
 
     def test_probe_no_ibus(self):
         with patch("voiceio.typers.ibus.shutil.which", return_value=None):

{python_voiceio-0.7.0 → python_voiceio-0.8.0}/tests/test_streaming.py

@@ -678,15 +678,21 @@ class TestSegmentFreeze:
         )
         return session, transcriber, recorder
 
-    def test_freeze_triggers_on_long_silent_tail(self):
+    def test_freeze_cuts_at_interior_pause(self):
         s, tr, rec = self._make_session(freeze_secs=2.0)
-        rec.get_audio_so_far.return_value = _silent(3)
+        # 2.5s speech, 0.5s pause, 2s speech: cut must land in the pause
+        rec.get_audio_so_far.return_value = np.concatenate(
+            [_loud(2.5), _silent(0.5), _loud(2.0)])
         tr.transcribe.return_value = "hello there friend"
         s._transcribe_and_apply()
         assert s._frozen_raw == "hello there friend"
-        assert s._frozen_samples == SR * 3
-        # Freeze pass gets beam search (final=True)
+        # Boundary inside the pause (2.5s..3.0s), NOT at the end of audio
+        assert SR * 2.5 <= s._frozen_samples <= SR * 3.0
+        # Freeze pass gets beam search and decodes ONLY the chunk
         assert tr.transcribe.call_args.kwargs["final"] is True
+        assert len(tr.transcribe.call_args.args[0]) == s._frozen_samples
+        # Display untouched: interim text already covers this audio
+        s._typer.type_text.assert_not_called()
 
     def test_no_freeze_when_tail_is_speech(self):
         s, tr, rec = self._make_session(freeze_secs=2.0)
@@ -785,16 +791,15 @@ class TestDecodeTrace:
             freeze_secs=2.0,
         )
         transcriber.transcribe.return_value = "hello there friend"
-        rec_audio = _silent(3)
-        recorder.get_audio_so_far.return_value = rec_audio
-        s._transcribe_and_apply()  # freeze pass
+        recorder.get_audio_so_far.return_value = _silent(3)
+        s._transcribe_and_apply()  # freeze pass (interior cut in silence)
         s._final_audio = np.concatenate([_silent(3), _loud(1)])
         transcriber.transcribe.return_value = "bye"
         s._transcribe_and_apply(min_seconds=0.5, final=True)
         kinds = [p["kind"] for p in s.trace]
         assert kinds == ["freeze", "final"]
         assert s.trace[0]["text"] == "hello there friend"
-        assert s.trace[1]["tail_secs"] == 1.0
+        assert s.trace[1]["tail_secs"] > 0
         assert all("secs" in p for p in s.trace)
 
 
@@ -856,31 +861,34 @@ class TestDecodeFailureSafety:
         s._typer.delete_chars.assert_not_called()
         assert s._typed_text == "hello there friend how are"
 
-    def test_quiet_mic_speech_is_not_silence(self):
-        from voiceio.streaming import _tail_ends_in_silence
+    def test_quiet_mic_speech_finds_no_cut(self):
+        from voiceio.streaming import _find_freeze_cut
         # Continuous speech on a low-gain mic: quiet in absolute terms but
-        # uniform — trailing window matches overall level, so NOT a pause.
+        # uniform — no window is quiet relative to the tail, so no cut.
         quiet_speech = np.full(SR * 3, 0.005, dtype=np.float32)
-        assert not _tail_ends_in_silence(quiet_speech, SR)
-        # Same quiet mic with a real trailing pause IS a pause.
+        assert _find_freeze_cut(quiet_speech, SR, 2.0) is None
+        # Same quiet mic with a real pause after the threshold IS cuttable.
         with_pause = np.concatenate([
-            np.full(int(SR * 2.5), 0.005, dtype=np.float32), _silent(0.5),
+            np.full(int(SR * 2.2), 0.005, dtype=np.float32), _silent(0.5),
+            np.full(int(SR * 0.3), 0.005, dtype=np.float32),
         ])
-        assert _tail_ends_in_silence(with_pause, SR)
+        cut = _find_freeze_cut(with_pause, SR, 2.0)
+        assert cut is not None and SR * 2.2 <= cut <= SR * 2.8
 
 
 class TestFreezeCalibration:
-    def test_hot_noise_floor_pause_is_silence(self):
+    def test_hot_noise_floor_pause_is_cuttable(self):
         """Real-mic calibration: noise floor ~0.3x of tail RMS IS a pause."""
-        from voiceio.streaming import _tail_ends_in_silence
+        from voiceio.streaming import _find_freeze_cut
         speech = np.full(int(SR * 2.5), 0.12, dtype=np.float32)
         pause = np.full(int(SR * 0.5), 0.03, dtype=np.float32)  # noise floor
-        assert _tail_ends_in_silence(np.concatenate([speech, pause]), SR)
+        cut = _find_freeze_cut(np.concatenate([speech, pause]), SR, 2.0)
+        assert cut is not None and cut >= SR * 2.3
 
-    def test_speech_level_window_is_not_silence(self):
-        from voiceio.streaming import _tail_ends_in_silence
+    def test_speech_level_tail_has_no_cut(self):
+        from voiceio.streaming import _find_freeze_cut
         tail = np.full(SR * 3, 0.12, dtype=np.float32)
-        assert not _tail_ends_in_silence(tail, SR)
+        assert _find_freeze_cut(tail, SR, 2.0) is None
 
 
 class TestDecodeBackpressure:

python_voiceio-0.8.0/voiceio/__init__.py

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

{python_voiceio-0.7.0 → python_voiceio-0.8.0}/voiceio/app.py

@@ -234,6 +234,11 @@ class VoiceIO:
         # IBus engine management
         self._prev_ibus_engine: str | None = None
         self._engine_proc: subprocess.Popen | None = None
+        # Engine lifecycle: consecutive missed pings (one miss on a busy
+        # system is not a zombie) and a guard against concurrent spawns
+        # (health loop vs record-start).
+        self._engine_ping_fails = 0
+        self._engine_spawn_lock = threading.Lock()
         self._shutdown = threading.Event()
         # IBus input-source ownership. We claim the GNOME input source ONLY
         # while a recording is live (RECORDING/FINALIZING) and restore whatever
@@ -366,6 +371,15 @@ class VoiceIO:
 
         self._state = _State.RECORDING
         self._ibus_session_fallback = False
+        if self._typer.name == "ibus" and self._engine_proc is None:
+            # Engine was reaped while dormant (normal — see _check_health).
+            # Respawn in the background; the engine's pending buffer holds
+            # preedits until the instance is ready, and with state=RECORDING
+            # the spawn leaves the voiceio source active instead of yanking
+            # it back to dormant mid-recording.
+            threading.Thread(
+                target=self._respawn_engine_for_recording, daemon=True,
+            ).start()
         self._activate_ibus()
         self._corrections.load()  # hot-reload corrections on each recording
         self._refresh_hotwords()  # hot-reload vocabulary (mtime-cached)
@@ -898,8 +912,29 @@ class VoiceIO:
 
     # ── IBus engine lifecycle ───────────────────────────────────────────
 
+    def _respawn_engine_for_recording(self) -> None:
+        """Background lazy respawn at record start. Never raises."""
+        try:
+            self._ensure_ibus_engine()
+        except Exception:
+            log.exception("IBus engine respawn at record start failed")
+
     def _ensure_ibus_engine(self) -> None:
-        """Start the VoiceIO IBus engine and activate it."""
+        """Start the VoiceIO IBus engine and activate it.
+
+        Single-flight: a concurrent spawn (health loop vs record start)
+        is skipped rather than queued — two dances would fight over the
+        input source.
+        """
+        if not self._engine_spawn_lock.acquire(blocking=False):
+            log.debug("IBus engine spawn already in progress, skipping")
+            return
+        try:
+            self._spawn_ibus_engine()
+        finally:
+            self._engine_spawn_lock.release()
+
+    def _spawn_ibus_engine(self) -> None:
         from voiceio.ibus import READY_PATH, SOCKET_PATH
         from voiceio.typers.ibus import LAUNCHER_PATH, _ibus_env
 
@@ -976,9 +1011,16 @@ class VoiceIO:
         except subprocess.TimeoutExpired:
             activate_proc.kill()
 
-        # Return to dormancy on the user's real source (not hardcoded 0).
-        self._set_gnome_input_source_index(dormant_idx if dormant_idx is not None else 0)
-        log.info("VoiceIO IBus engine ready (dormant until recording)")
+        # Return to dormancy on the user's real source (not hardcoded 0) —
+        # unless a recording claimed the source while we were spawning:
+        # yanking it away now would kill the live preedit for that whole
+        # recording (the "underlined text never appears" symptom).
+        if self._state == _State.IDLE:
+            self._set_gnome_input_source_index(dormant_idx if dormant_idx is not None else 0)
+            self._release_ibus_engine()
+            log.info("VoiceIO IBus engine ready (dormant until recording)")
+        else:
+            log.info("VoiceIO IBus engine ready (recording live — staying active)")
 
     def _ping_ibus_engine(self) -> bool:
         """Check if the IBus engine's socket listener is alive.
@@ -991,7 +1033,7 @@ class VoiceIO:
         from voiceio.ibus import SOCKET_PATH
         try:
             sock = _socket.socket(_socket.AF_UNIX, _socket.SOCK_DGRAM)
-            sock.settimeout(1.0)
+            sock.settimeout(2.0)
             sock.bind("")
             sock.sendto(b"ping", str(SOCKET_PATH))
             data, _ = sock.recvfrom(64)
@@ -1091,6 +1133,49 @@ class VoiceIO:
         self._set_gnome_input_source_index(idx if idx is not None else 0)
         self._prev_input_source_index = None
         self._voiceio_source_index = None
+        self._release_ibus_engine()
+
+    def _ibus_engine_fallback(self) -> str:
+        """The user's non-voiceio ibus engine name, for releasing the engine."""
+        if self._prev_ibus_engine and self._prev_ibus_engine != "voiceio":
+            return self._prev_ibus_engine
+        try:
+            result = subprocess.run(
+                ["gsettings", "get", "org.gnome.desktop.input-sources", "sources"],
+                capture_output=True, text=True, timeout=3,
+            )
+            import ast
+            for kind, name in ast.literal_eval(result.stdout.strip()):
+                if kind == "xkb":
+                    return f"xkb:{name}::eng"
+        except Exception:
+            pass
+        return "xkb:us::eng"
+
+    def _release_ibus_engine(self) -> None:
+        """Point ibus's GLOBAL engine back at the user's layout when dormant.
+
+        Restoring the GNOME input source is not enough: the spawn dance sets
+        the global engine directly (`ibus engine voiceio`), and a gsettings
+        write that doesn't change the value never makes GNOME push an engine
+        change. The stale global engine then routes EVERY input context
+        through voiceio while "dormant" — constant focus churn that discards
+        any visible preedit, surviving daemon restarts.
+        """
+        from voiceio.typers.ibus import _ibus_env
+        try:
+            # Unconditional: querying first races the (async) activation —
+            # a stale reading made the release skip itself and left voiceio
+            # active. Going dormant means the user's engine should be the
+            # global one; setting it is idempotent.
+            fallback = self._ibus_engine_fallback()
+            subprocess.run(
+                ["ibus", "engine", fallback],
+                capture_output=True, timeout=3, env=_ibus_env(),
+            )
+            log.debug("Released ibus global engine to %s", fallback)
+        except (FileNotFoundError, subprocess.TimeoutExpired):
+            pass
 
     def _switch_gnome_input_source(self, engine_name: str) -> None:
         if not self.platform.is_gnome:
@@ -1124,6 +1209,16 @@ class VoiceIO:
                          "current", str(i)],
                         capture_output=True, timeout=3,
                     )
+                    # The gsettings write alone is a no-op on newer GNOME
+                    # (the 'current' key is legacy) — activation only ever
+                    # worked while the global engine was accidentally stuck
+                    # on voiceio. Claim it explicitly, mirroring
+                    # _release_ibus_engine() on deactivation.
+                    from voiceio.typers.ibus import _ibus_env
+                    subprocess.run(
+                        ["ibus", "engine", engine_name],
+                        capture_output=True, timeout=3, env=_ibus_env(),
+                    )
                     log.info("Switched GNOME input source to index %d (%s)", i, engine_name)
                     time.sleep(0.5)
                     return
@@ -1216,17 +1311,13 @@ class VoiceIO:
         # of ibus) — the preferred backend may be available now.
         self._try_upgrade_typer(reason="resume")
 
-        # IBus: restart the engine only if its process died. Never re-force the
-        # active input source on resume — activation happens on record-start.
+        # IBus: an engine that died during sleep is respawned lazily at the
+        # next record start (same as health-loop reaping — respawning here
+        # would grab the input source right as the user unlocks).
         if self._typer.name == "ibus" and self._engine_proc is not None:
             if self._engine_proc.poll() is not None:
-                # Engine process died during sleep
+                log.debug("Resume: IBus engine died during sleep — will respawn at next recording")
                 self._engine_proc = None
-                try:
-                    self._ensure_ibus_engine()
-                    log.info("Resume: IBus engine restarted")
-                except Exception:
-                    log.exception("Resume: IBus engine restart failed")
 
         # Tray: restart if subprocess died
         if self.cfg.tray.enabled and not tray.is_alive():
@@ -1295,29 +1386,45 @@ class VoiceIO:
         if self._state == _State.IDLE:
             self._health_typer_upkeep()
 
-        # Check IBus engine liveness. When IDLE we ONLY restart a dead/zombie
-        # engine process — we never re-force the active input source, so we
-        # don't fight users running a real IME. When a recording is live we
-        # watch for the user switching source away from us and fall back.
+        # Check IBus engine liveness. A dormant engine dying is NORMAL:
+        # ibus-daemon reaps deactivated engine processes (SIGTERM ~10s after
+        # the input source switches away). Eagerly respawning here created a
+        # spawn→activate→dormant→reap loop that grabbed the user's input
+        # source every cycle — the focus churn wiped any visible preedit
+        # (flickering underline). Respawn lazily at the next record start.
         if self._typer.name == "ibus" and self._engine_proc is not None:
             if self._engine_proc.poll() is not None:
-                log.warning("IBus engine process died (rc=%d), restarting",
-                            self._engine_proc.returncode)
+                rc = self._engine_proc.returncode
                 self._engine_proc = None
-                try:
-                    self._ensure_ibus_engine()
-                    log.info("IBus engine recovered")
-                except Exception:
-                    log.exception("IBus engine recovery failed")
+                self._engine_ping_fails = 0
+                if self._state == _State.IDLE:
+                    log.debug(
+                        "IBus engine exited while dormant (rc=%s) — normal "
+                        "reaping, will respawn at next recording", rc,
+                    )
+                else:
+                    log.warning("IBus engine died mid-recording (rc=%s), restarting", rc)
+                    try:
+                        self._ensure_ibus_engine()
+                        log.info("IBus engine recovered")
+                    except Exception:
+                        log.exception("IBus engine recovery failed")
             elif self._state == _State.IDLE:
                 # Engine process alive — check if its socket listener is
                 # actually responding. A zombie engine (process alive but
                 # GLib loop stuck / socket thread dead) silently drops all
-                # preedit and commit messages, causing the "transcription
-                # works but no text appears" symptom. Restart it, but do NOT
-                # touch the active input source.
+                # preedit and commit messages. One missed ping on a loaded
+                # system is not a zombie — require two consecutive misses.
                 if not self._ping_ibus_engine():
+                    self._engine_ping_fails += 1
+                    if self._engine_ping_fails < 2:
+                        log.debug(
+                            "IBus engine missed a ping (%d/2) — busy system?",
+                            self._engine_ping_fails,
+                        )
+                        return
                     log.warning("IBus engine not responding to ping, restarting")
+                    self._engine_ping_fails = 0
                     self._engine_proc.kill()
                     try:
                         self._engine_proc.wait(timeout=3)
@@ -1329,6 +1436,8 @@ class VoiceIO:
                         log.info("IBus engine recovered (was zombie)")
                     except Exception:
                         log.exception("IBus engine recovery failed")
+                else:
+                    self._engine_ping_fails = 0
             else:
                 # RECORDING / FINALIZING: don't re-force the source; if the
                 # user switched away from voiceio, fall back to clipboard.

{python_voiceio-0.7.0 → python_voiceio-0.8.0}/voiceio/clipboard_read.py

@@ -70,10 +70,19 @@ def read_text() -> str | None:
 
 
 def _copy_via(cmd: list[str], text: str) -> bool:
-    """Pipe text into a copy command. Returns True on success."""
+    """Pipe text into a copy command. Returns True on success.
+
+    stdout/stderr go to DEVNULL, NOT pipes: xclip daemonizes (forks a child
+    that owns the selection and inherits the fds), so captured pipes never
+    reach EOF and run() would block for the full timeout, then report a
+    bogus failure — which used to trigger the wl-copy fallback and its
+    focus steal on every single copy.
+    """
     try:
         result = subprocess.run(
-            cmd, input=text.encode(), capture_output=True, timeout=_TIMEOUT,
+            cmd, input=text.encode(),
+            stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
+            timeout=_TIMEOUT,
         )
         return result.returncode == 0
     except (FileNotFoundError, subprocess.TimeoutExpired, OSError):
@@ -103,6 +112,13 @@ def copy_text(text: str) -> bool:
         return _copy_via(["pbcopy"], text)
 
     if p.is_wayland:
+        # Prefer xclip via the XWayland clipboard bridge: wl-copy can
+        # momentarily steal keyboard focus on GNOME (fallback surface),
+        # and a focus-out discards any visible IBus preedit — streaming
+        # milestone copies were wiping the underlined preview one frame
+        # after it painted. X11 selections never touch Wayland focus.
+        if shutil.which("xclip") and _copy_via(["xclip", "-selection", "clipboard"], text):
+            return True
         if shutil.which("wl-copy"):
             return _copy_via(["wl-copy", "--"], text)
     else:

{python_voiceio-0.7.0 → python_voiceio-0.8.0}/voiceio/config.py

@@ -85,10 +85,12 @@ class OutputConfig:
     number_conversion: bool = True
     voice_input_prefix: str = ""           # e.g. "[voice]" — empty disables
     # Incremental finalization: once the un-finalized audio tail grows past
-    # this many seconds AND ends in silence, beam-decode and freeze it during
-    # recording, so interim passes and the stop-time final decode only cover
-    # the short remaining tail. 0 disables (full re-decode at stop).
-    streaming_freeze_secs: float = 25.0
+    # this many seconds, it is cut at the nearest interior speech pause,
+    # beam-decoded and frozen during recording, so interim passes and the
+    # stop-time final decode only cover the short remaining tail. Smaller
+    # chunks decode faster (less worker blocking) at slightly more boundary
+    # risk. 0 disables (full re-decode at stop).
+    streaming_freeze_secs: float = 15.0
     # Mirror transcribed text to the system clipboard so it can be pasted:
     #   "off"   — never
     #   "final" — the corrected final text, once ready

{python_voiceio-0.7.0 → python_voiceio-0.8.0}/voiceio/ibus/engine.py

@@ -43,9 +43,13 @@ class VoiceIOEngine(IBus.Engine):
         log.info("VoiceIOEngine instance created (path=%s)", kwargs.get("object_path"))
 
     def do_focus_in(self):
+        # Focus transitions also discard any visible preedit (IBus default
+        # mode), so log them — a flickering preedit is usually focus churn.
+        log.debug("focus_in")
         self._focused = True
 
     def do_focus_out(self):
+        log.debug("focus_out (preedit discarded by client if visible)")
         self._focused = False
 
     def do_process_key_event(self, keyval, keycode, state):