python-voiceio 0.3.3__tar.gz → 0.3.5__tar.gz

{python_voiceio-0.3.3/python_voiceio.egg-info → python_voiceio-0.3.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-voiceio
-Version: 0.3.3
+Version: 0.3.5
 Summary: Speak → text, locally, instantly.
 Author: Hugo Montenegro
 License-Expression: MIT

{python_voiceio-0.3.3 → python_voiceio-0.3.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-voiceio"
-version = "0.3.3"
+version = "0.3.5"
 description = "Speak → text, locally, instantly."
 readme = "README.md"
 license = "MIT"

{python_voiceio-0.3.3 → python_voiceio-0.3.5/python_voiceio.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-voiceio
-Version: 0.3.3
+Version: 0.3.5
 Summary: Speak → text, locally, instantly.
 Author: Hugo Montenegro
 License-Expression: MIT

{python_voiceio-0.3.3 → python_voiceio-0.3.5}/python_voiceio.egg-info/SOURCES.txt

@@ -27,6 +27,7 @@ tests/test_postprocess.py
 tests/test_prebuffer.py
 tests/test_prompt.py
 tests/test_recorder_integration.py
+tests/test_robustness.py
 tests/test_streaming.py
 tests/test_transcriber.py
 tests/test_tts.py

python_voiceio-0.3.5/tests/test_robustness.py

@@ -0,0 +1,526 @@
+"""Tests for robustness features: stream health, tray watchdog, audio backoff."""
+from __future__ import annotations
+
+import threading
+import time
+from unittest.mock import MagicMock, patch
+
+import numpy as np
+from voiceio.config import Config
+
+
+# ---------------------------------------------------------------------------
+# Helpers (same pattern as test_app_wiring.py)
+# ---------------------------------------------------------------------------
+
+def _make_vio(mock_transcriber=None):
+    """Create a VoiceIO instance with mocked backends."""
+    mock_hotkey = MagicMock()
+    mock_hotkey.name = "socket"
+    mock_typer = MagicMock()
+    mock_typer.name = "clipboard"
+    if mock_transcriber is None:
+        mock_transcriber = MagicMock()
+
+    with patch("voiceio.app.hotkey_chain.select", return_value=mock_hotkey), \
+         patch("voiceio.app.typer_chain.select", return_value=mock_typer), \
+         patch("voiceio.app.Transcriber", return_value=mock_transcriber), \
+         patch("voiceio.app.plat.detect") as mock_detect:
+        mock_detect.return_value = MagicMock(display_server="wayland", desktop="gnome")
+
+        from voiceio.app import VoiceIO
+        vio = VoiceIO(Config())
+        mock_stream = MagicMock()
+        mock_stream.active = True
+        mock_stream.closed = False
+        mock_stream.stopped = False
+        vio.recorder._stream = mock_stream
+        vio.recorder._last_callback_time = time.monotonic()
+        return vio, mock_typer, mock_transcriber
+
+
+def _feed_audio(vio, chunks=20):
+    """Feed fake audio data into the recorder."""
+    for _ in range(chunks):
+        data = np.full((1024, 1), 0.3, dtype=np.float32)
+        vio.recorder._callback(data, 1024, None, None)
+
+
+def _allow_stop(vio):
+    """Set timestamps far back so debounce allows stop."""
+    vio._record_start = time.monotonic() - 5.0
+    vio._last_hotkey = time.monotonic() - 5.0
+
+
+def _make_recorder():
+    """Create a standalone AudioRecorder with mocked dependencies."""
+    cfg = MagicMock()
+    cfg.sample_rate = 16000
+    cfg.device = "default"
+    cfg.prebuffer_secs = 1.0
+    cfg.silence_threshold = 0.01
+    cfg.silence_duration = 0.6
+    cfg.auto_stop_silence_secs = 5.0
+
+    with patch("voiceio.recorder.sd"):
+        from voiceio.recorder import AudioRecorder
+        vad = MagicMock()
+        vad.is_speech.return_value = False
+        rec = AudioRecorder(cfg, vad=vad)
+    return rec
+
+
+# ===========================================================================
+# 1. stream_health() tests
+# ===========================================================================
+
+class TestStreamHealth:
+    def test_healthy_stream(self):
+        rec = _make_recorder()
+        mock_stream = MagicMock()
+        mock_stream.active = True
+        mock_stream.closed = False
+        mock_stream.stopped = False
+        rec._stream = mock_stream
+        rec._last_callback_time = time.monotonic()
+
+        ok, reason = rec.stream_health()
+        assert ok is True
+        assert reason == ""
+
+    def test_stream_is_none(self):
+        rec = _make_recorder()
+        rec._stream = None
+
+        ok, reason = rec.stream_health()
+        assert ok is False
+        assert reason == "stream is None"
+
+    def test_stream_closed(self):
+        rec = _make_recorder()
+        mock_stream = MagicMock()
+        mock_stream.closed = True
+        rec._stream = mock_stream
+
+        ok, reason = rec.stream_health()
+        assert ok is False
+        assert reason == "stream closed"
+
+    def test_stream_not_active(self):
+        rec = _make_recorder()
+        mock_stream = MagicMock()
+        mock_stream.closed = False
+        mock_stream.active = False
+        rec._stream = mock_stream
+
+        ok, reason = rec.stream_health()
+        assert ok is False
+        assert reason == "stream not active"
+
+    def test_stream_stopped(self):
+        rec = _make_recorder()
+        mock_stream = MagicMock()
+        mock_stream.closed = False
+        mock_stream.active = True
+        mock_stream.stopped = True
+        rec._stream = mock_stream
+
+        ok, reason = rec.stream_health()
+        assert ok is False
+        assert reason == "stream stopped"
+
+    def test_stale_heartbeat(self):
+        rec = _make_recorder()
+        mock_stream = MagicMock()
+        mock_stream.active = True
+        mock_stream.closed = False
+        mock_stream.stopped = False
+        rec._stream = mock_stream
+        # Set heartbeat to 10 seconds ago (exceeds _HEARTBEAT_TIMEOUT of 5s)
+        rec._last_callback_time = time.monotonic() - 10.0
+
+        ok, reason = rec.stream_health()
+        assert ok is False
+        assert "no audio callback for" in reason
+
+    def test_healthy_with_no_heartbeat_yet(self):
+        """Before any callback fires, heartbeat is 0.0 — should be healthy."""
+        rec = _make_recorder()
+        mock_stream = MagicMock()
+        mock_stream.active = True
+        mock_stream.closed = False
+        mock_stream.stopped = False
+        rec._stream = mock_stream
+        rec._last_callback_time = 0.0  # never set
+
+        ok, reason = rec.stream_health()
+        assert ok is True
+        assert reason == ""
+
+
+# ===========================================================================
+# 2. has_signal() tests
+# ===========================================================================
+
+class TestHasSignal:
+    def test_empty_ring_buffer(self):
+        rec = _make_recorder()
+        # Ring buffer is empty by default (no audio fed)
+        assert rec.has_signal() is False
+
+    def test_all_zeros(self):
+        rec = _make_recorder()
+        # Feed silent audio (all zeros)
+        silent = np.zeros((1024, 1), dtype=np.float32)
+        rec._ring.append(silent)
+
+        assert rec.has_signal() is False
+
+    def test_real_audio(self):
+        rec = _make_recorder()
+        # Feed audio with real signal
+        audio = np.full((1024, 1), 0.05, dtype=np.float32)
+        rec._ring.append(audio)
+
+        assert rec.has_signal() is True
+
+    def test_barely_above_threshold(self):
+        """Signal just above 1e-4 threshold should be detected."""
+        rec = _make_recorder()
+        audio = np.full((1024, 1), 2e-4, dtype=np.float32)
+        rec._ring.append(audio)
+
+        assert rec.has_signal() is True
+
+    def test_barely_below_threshold(self):
+        """Signal at exactly 1e-4 or below should not be detected."""
+        rec = _make_recorder()
+        audio = np.full((1024, 1), 1e-5, dtype=np.float32)
+        rec._ring.append(audio)
+
+        assert rec.has_signal() is False
+
+
+# ===========================================================================
+# 3. reopen_stream() tests
+# ===========================================================================
+
+class TestReopenStream:
+    def test_closes_and_reopens(self):
+        rec = _make_recorder()
+        mock_stream = MagicMock()
+        mock_stream.active = True
+        mock_stream.closed = False
+        mock_stream.stopped = False
+        rec._stream = mock_stream
+        rec._last_callback_time = time.monotonic()
+
+        with patch("voiceio.recorder.sd") as mock_sd:
+            new_stream = MagicMock()
+            mock_sd.InputStream.return_value = new_stream
+            rec.reopen_stream()
+
+        # Old stream should have been stopped and closed
+        mock_stream.stop.assert_called_once()
+        mock_stream.close.assert_called_once()
+        # New stream should be opened and started
+        new_stream.start.assert_called_once()
+        assert rec._stream is new_stream
+
+    def test_resets_heartbeat(self):
+        rec = _make_recorder()
+        mock_stream = MagicMock()
+        rec._stream = mock_stream
+        rec._last_callback_time = time.monotonic() - 100.0
+
+        with patch("voiceio.recorder.sd") as mock_sd:
+            mock_sd.InputStream.return_value = MagicMock()
+            rec.reopen_stream()
+
+        assert rec._last_callback_time == 0.0
+
+
+# ===========================================================================
+# 4. tray is_alive() tests
+# ===========================================================================
+
+class TestTrayIsAlive:
+    def test_indicator_alive(self):
+        mock_proc = MagicMock()
+        mock_proc.poll.return_value = None  # still running
+
+        with patch("voiceio.tray._proc", mock_proc), \
+             patch("voiceio.tray._backend", "indicator"):
+            from voiceio import tray
+            assert tray.is_alive() is True
+
+    def test_indicator_dead(self):
+        mock_proc = MagicMock()
+        mock_proc.poll.return_value = 1  # exited with code 1
+
+        with patch("voiceio.tray._proc", mock_proc), \
+             patch("voiceio.tray._backend", "indicator"):
+            from voiceio import tray
+            assert tray.is_alive() is False
+
+    def test_indicator_proc_none(self):
+        with patch("voiceio.tray._proc", None), \
+             patch("voiceio.tray._backend", "indicator"):
+            from voiceio import tray
+            assert tray.is_alive() is False
+
+    def test_pystray_alive(self):
+        with patch("voiceio.tray._backend", "pystray"):
+            from voiceio import tray
+            assert tray.is_alive() is True
+
+    def test_no_backend(self):
+        with patch("voiceio.tray._backend", None):
+            from voiceio import tray
+            assert tray.is_alive() is False
+
+
+# ===========================================================================
+# 5. Health watchdog audio backoff tests
+# ===========================================================================
+
+class TestHealthWatchdogAudioBackoff:
+    def test_stream_failure_triggers_reopen(self):
+        vio, _, _ = _make_vio()
+        vio.recorder.stream_health = MagicMock(return_value=(False, "stream not active"))
+        vio.recorder.reopen_stream = MagicMock()
+        vio.transcriber.is_worker_alive = MagicMock(return_value=True)
+
+        with patch("voiceio.app.tray"):
+            vio._check_health()
+
+        vio.recorder.reopen_stream.assert_called_once()
+
+    def test_successful_recovery_resets_backoff(self):
+        vio, _, _ = _make_vio()
+        vio._stream_fail_count = 3
+        vio._next_stream_retry = 0  # allow retry
+        vio.recorder.stream_health = MagicMock(return_value=(False, "stream not active"))
+        vio.recorder.reopen_stream = MagicMock()  # succeeds (no exception)
+        vio.transcriber.is_worker_alive = MagicMock(return_value=True)
+
+        with patch("voiceio.app.tray"):
+            vio._check_health()
+
+        assert vio._stream_fail_count == 0
+        assert vio._next_stream_retry == 0
+
+    def test_failed_recovery_increments_backoff(self):
+        vio, _, _ = _make_vio()
+        vio._stream_fail_count = 0
+        vio._next_stream_retry = 0
+        vio.recorder.stream_health = MagicMock(return_value=(False, "stream not active"))
+        vio.recorder.reopen_stream = MagicMock(side_effect=OSError("device gone"))
+        vio.transcriber.is_worker_alive = MagicMock(return_value=True)
+
+        with patch("voiceio.app.tray"):
+            vio._check_health()
+
+        assert vio._stream_fail_count == 1
+        assert vio._next_stream_retry > 0
+
+    def test_backoff_skips_retry(self):
+        """When in backoff, _check_health should not attempt reopen."""
+        vio, _, _ = _make_vio()
+        vio._stream_fail_count = 2
+        vio._next_stream_retry = time.monotonic() + 999  # far future
+        vio.recorder.stream_health = MagicMock(return_value=(False, "stream not active"))
+        vio.recorder.reopen_stream = MagicMock()
+        vio.transcriber.is_worker_alive = MagicMock(return_value=True)
+
+        with patch("voiceio.app.tray"):
+            vio._check_health()
+
+        vio.recorder.reopen_stream.assert_not_called()
+
+    def test_external_recovery_resets_backoff(self):
+        """If stream becomes healthy on its own, backoff resets."""
+        vio, _, _ = _make_vio()
+        vio._stream_fail_count = 3
+        vio._next_stream_retry = time.monotonic() + 100
+        vio.recorder.stream_health = MagicMock(return_value=(True, ""))
+        vio.transcriber.is_worker_alive = MagicMock(return_value=True)
+
+        with patch("voiceio.app.tray"):
+            vio._check_health()
+
+        assert vio._stream_fail_count == 0
+        assert vio._next_stream_retry == 0
+
+    def test_repeated_failures_increase_delay(self):
+        """Each failure should increase the backoff delay."""
+        vio, _, _ = _make_vio()
+        vio.recorder.stream_health = MagicMock(return_value=(False, "stream not active"))
+        vio.recorder.reopen_stream = MagicMock(side_effect=OSError("device gone"))
+        vio.transcriber.is_worker_alive = MagicMock(return_value=True)
+
+        delays = []
+        with patch("voiceio.app.tray"):
+            for _ in range(3):
+                vio._next_stream_retry = 0  # allow retry each time
+                before = time.monotonic()
+                vio._check_health()
+                delays.append(vio._next_stream_retry - before)
+
+        # Each delay should be larger (10, 20, 40)
+        assert delays[0] < delays[1] < delays[2]
+
+
+# ===========================================================================
+# 6. Pre-flight stream check in _do_start()
+# ===========================================================================
+
+class TestPreFlightStreamCheck:
+    def test_unhealthy_stream_gets_reopened(self):
+        vio, _, _ = _make_vio()
+        vio.recorder.stream_health = MagicMock(return_value=(False, "stream not active"))
+        vio.recorder.reopen_stream = MagicMock()
+        vio.recorder.has_signal = MagicMock(return_value=True)
+
+        vio.on_hotkey()
+
+        vio.recorder.reopen_stream.assert_called_once()
+        assert vio.recorder.is_recording
+
+    def test_recording_aborts_if_reopen_fails(self):
+        from voiceio.app import _State
+
+        vio, _, _ = _make_vio()
+        vio.recorder.stream_health = MagicMock(return_value=(False, "stream not active"))
+        vio.recorder.reopen_stream = MagicMock(side_effect=OSError("no device"))
+
+        vio.on_hotkey()
+
+        # Recording should NOT have started
+        assert not vio.recorder.is_recording
+        assert vio._state == _State.IDLE
+
+    def test_healthy_stream_no_reopen(self):
+        vio, _, _ = _make_vio()
+        vio.recorder.stream_health = MagicMock(return_value=(True, ""))
+        vio.recorder.reopen_stream = MagicMock()
+        vio.recorder.has_signal = MagicMock(return_value=True)
+
+        vio.on_hotkey()
+
+        vio.recorder.reopen_stream.assert_not_called()
+        assert vio.recorder.is_recording
+
+
+# ===========================================================================
+# 7. Streaming worker exception handling
+# ===========================================================================
+
+class TestStreamingWorkerExceptionHandling:
+    def test_worker_catches_exception_and_continues(self):
+        """Worker loop should catch exceptions in _transcribe_and_apply and keep running."""
+        mock_transcriber = MagicMock()
+        mock_typer = MagicMock()
+        mock_typer.name = "clipboard"
+        mock_recorder = MagicMock()
+        mock_recorder.sample_rate = 16000
+        mock_recorder.get_audio_so_far.return_value = np.zeros(32000, dtype=np.float32)
+
+        from voiceio.streaming import StreamingSession
+
+        session = StreamingSession(
+            mock_transcriber, mock_typer, mock_recorder,
+            generation=0,
+        )
+
+        call_count = 0
+
+        def flaky_transcribe(*args, **kwargs):
+            nonlocal call_count
+            call_count += 1
+            if call_count <= 2:
+                raise RuntimeError("transient error")
+            # On 3rd call, stop the session to let the test finish
+            session._stop_event.set()
+
+        session._transcribe_and_apply = flaky_transcribe
+
+        # Start the worker (runs in its own thread)
+        session._stop_event = threading.Event()
+        session._pending = threading.Event()
+        session._pending.set()  # trigger immediate processing
+
+        worker = threading.Thread(target=session._worker_loop, daemon=True)
+        worker.start()
+
+        # Wait for the worker to process through the exceptions
+        worker.join(timeout=5)
+        assert not worker.is_alive(), "Worker thread should have exited"
+        # Worker called our function multiple times without dying
+        assert call_count >= 2, f"Expected at least 2 calls, got {call_count}"
+
+    def test_final_transcription_exception_does_not_crash(self):
+        """Exception during final transcription should be caught."""
+        mock_transcriber = MagicMock()
+        mock_transcriber.transcribe.side_effect = RuntimeError("model crash")
+        mock_typer = MagicMock()
+        mock_typer.name = "clipboard"
+        mock_recorder = MagicMock()
+        mock_recorder.sample_rate = 16000
+        mock_recorder.get_audio_so_far.return_value = np.zeros(32000, dtype=np.float32)
+
+        from voiceio.streaming import StreamingSession
+
+        session = StreamingSession(
+            mock_transcriber, mock_typer, mock_recorder,
+            generation=0,
+        )
+
+        # Set up for immediate stop (skip the main loop, just do final pass)
+        session._stop_event.set()
+        session._pending.set()
+        session._final_audio = np.zeros(32000, dtype=np.float32)
+
+        # Should not raise — exceptions caught inside _worker_loop
+        worker = threading.Thread(target=session._worker_loop, daemon=True)
+        worker.start()
+        worker.join(timeout=5)
+        assert not worker.is_alive(), "Worker thread should have exited"
+
+
+# ===========================================================================
+# 8. Tray watchdog in _check_health()
+# ===========================================================================
+
+class TestTrayWatchdog:
+    def test_tray_restart_when_dead(self):
+        vio, _, _ = _make_vio()
+        vio.cfg.tray.enabled = True
+        vio.recorder.stream_health = MagicMock(return_value=(True, ""))
+        vio.transcriber.is_worker_alive = MagicMock(return_value=True)
+
+        with patch("voiceio.app.tray") as mock_tray:
+            mock_tray.is_alive.return_value = False
+            vio._check_health()
+            mock_tray.restart.assert_called_once_with(vio.on_hotkey)
+
+    def test_tray_not_restarted_when_alive(self):
+        vio, _, _ = _make_vio()
+        vio.cfg.tray.enabled = True
+        vio.recorder.stream_health = MagicMock(return_value=(True, ""))
+        vio.transcriber.is_worker_alive = MagicMock(return_value=True)
+
+        with patch("voiceio.app.tray") as mock_tray:
+            mock_tray.is_alive.return_value = True
+            vio._check_health()
+            mock_tray.restart.assert_not_called()
+
+    def test_tray_not_checked_when_disabled(self):
+        vio, _, _ = _make_vio()
+        vio.cfg.tray.enabled = False
+        vio.recorder.stream_health = MagicMock(return_value=(True, ""))
+        vio.transcriber.is_worker_alive = MagicMock(return_value=True)
+
+        with patch("voiceio.app.tray") as mock_tray:
+            vio._check_health()
+            mock_tray.is_alive.assert_not_called()

python_voiceio-0.3.5/voiceio/__init__.py

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

{python_voiceio-0.3.3 → python_voiceio-0.3.5}/voiceio/app.py

@@ -473,6 +473,34 @@ class VoiceIO:
         self._set_gnome_input_source_index(0)
         log.info("VoiceIO IBus engine ready (dormant until recording)")
 
+    def _reactivate_ibus_if_stale(self) -> None:
+        """Re-activate IBus engine if it lost registration (e.g. after hibernate).
+
+        After suspend/hibernate, the IBus daemon may forget about our engine.
+        Check by querying the current active engine; if it's not 'voiceio',
+        re-run ``ibus engine voiceio`` to re-register.
+        """
+        from voiceio.typers.ibus import _ibus_env
+        try:
+            result = subprocess.run(
+                ["ibus", "engine"], capture_output=True, text=True,
+                timeout=3, env=_ibus_env(),
+            )
+            current = result.stdout.strip() if result.returncode == 0 else ""
+        except (FileNotFoundError, subprocess.TimeoutExpired):
+            return
+        if current == "voiceio":
+            return  # still registered, nothing to do
+        log.warning("IBus engine stale (current=%r), re-activating", current)
+        try:
+            subprocess.run(
+                ["ibus", "engine", "voiceio"],
+                capture_output=True, timeout=5, env=_ibus_env(),
+            )
+            log.info("IBus engine re-activated")
+        except (FileNotFoundError, subprocess.TimeoutExpired) as e:
+            log.warning("IBus re-activation failed: %s", e)
+
     def _wait_for_ibus(self, chain: list[str]) -> TyperBackend | None:
         """Wait for IBus daemon to become available and switch to IBus typer.
 
@@ -584,17 +612,70 @@ class VoiceIO:
 
     # ── Health watchdog ─────────────────────────────────────────────
 
+    # If the gap between health checks exceeds this, we probably resumed
+    # from suspend/hibernate and should re-probe everything.
+    _RESUME_THRESHOLD = 30  # seconds
+
     def _health_loop(self) -> None:
         """Periodic health check: transcriber worker, IBus engine, audio stream."""
+        last_check = time.monotonic()
         while not self._shutdown.is_set():
             self._shutdown.wait(_HEALTH_CHECK_INTERVAL)
             if self._shutdown.is_set():
                 break
+
+            now = time.monotonic()
+            gap = now - last_check
+            last_check = now
+
             try:
+                if gap > self._RESUME_THRESHOLD:
+                    log.info("System resume detected (%.0fs gap), re-probing all backends", gap)
+                    self._on_resume()
                 self._check_health()
             except Exception:
                 log.debug("Health check error", exc_info=True)
 
+    def _on_resume(self) -> None:
+        """Re-probe all backends after system suspend/hibernate.
+
+        Sleep/hibernate breaks connections to system services (IBus, audio,
+        tray D-Bus, ydotoold) across all platforms. Instead of catching each
+        failure individually, do a single sweep to restore everything.
+        """
+        # Audio: reopen stream (device may have changed or died)
+        try:
+            self.recorder.reopen_stream()
+            log.info("Resume: audio stream reopened")
+        except Exception:
+            log.warning("Resume: audio stream reopen failed", exc_info=True)
+
+        # IBus: re-activate engine registration
+        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
+                self._engine_proc = None
+                try:
+                    self._ensure_ibus_engine()
+                    log.info("Resume: IBus engine restarted")
+                except Exception:
+                    log.exception("Resume: IBus engine restart failed")
+            else:
+                self._reactivate_ibus_if_stale()
+
+        # Tray: restart if subprocess died
+        if self.cfg.tray.enabled and not tray.is_alive():
+            log.info("Resume: restarting tray")
+            tray.restart(self.on_hotkey)
+
+        # Transcriber: ensure worker is alive
+        if not self.transcriber.is_worker_alive():
+            try:
+                self.transcriber._ensure_worker()
+                log.info("Resume: transcriber worker restarted")
+            except RuntimeError:
+                log.error("Resume: transcriber worker failed")
+
     def _check_health(self) -> None:
         """Run one health check cycle."""
         # Check transcriber worker
@@ -644,7 +725,7 @@ class VoiceIO:
             log.warning("Tray subprocess died, restarting")
             tray.restart(self.on_hotkey)
 
-        # Check IBus engine (restart if died)
+        # Check IBus engine (restart if died, re-activate if stale after resume)
         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",
@@ -655,6 +736,10 @@ class VoiceIO:
                     log.info("IBus engine recovered")
                 except Exception:
                     log.exception("IBus engine recovery failed")
+            elif self._state == _State.IDLE:
+                # Engine alive but may have lost IBus registration after
+                # hibernate/suspend. Re-activate so preedit works next time.
+                self._reactivate_ibus_if_stale()
 
     # ── Main loop ───────────────────────────────────────────────────────
 

{python_voiceio-0.3.3 → python_voiceio-0.3.5}/voiceio/cli.py

@@ -142,12 +142,12 @@ def _cmd_run(args: argparse.Namespace) -> None:
     elif args.no_notify_clipboard:
         cfg.feedback.notify_clipboard = False
 
-    # Console: show voiceio messages at configured level
+    # Console: show voiceio messages at configured level (visible in journalctl)
     console = logging.StreamHandler()
     console.setFormatter(logging.Formatter(
         "%(asctime)s %(name)s %(levelname)s %(message)s", datefmt="%H:%M:%S",
     ))
-    console.setLevel(logging.WARNING)
+    console.setLevel(getattr(logging, cfg.daemon.log_level))
 
     # File: always log DEBUG to rotating file
     from voiceio.config import LOG_DIR, LOG_PATH

{python_voiceio-0.3.3 → python_voiceio-0.3.5}/voiceio/service.py

@@ -57,6 +57,7 @@ Type=simple
 ExecStart={bin_path}
 Restart=on-failure
 RestartSec=3
+Environment=PYTHONUNBUFFERED=1
 PassEnvironment=DISPLAY WAYLAND_DISPLAY XDG_SESSION_TYPE XDG_RUNTIME_DIR
 
 [Install]

{python_voiceio-0.3.3 → python_voiceio-0.3.5}/voiceio/typers/ibus.py

@@ -384,10 +384,22 @@ class IBusTyper:
         except (OSError, socket.timeout):
             return True  # assume focused on error (safe default: no extra paste)
 
+    @staticmethod
+    def _ydotoold_running() -> bool:
+        """Check if ydotoold daemon is running (required for reliable ydotool)."""
+        try:
+            result = subprocess.run(
+                ["pgrep", "-x", "ydotoold"],
+                capture_output=True, timeout=2,
+            )
+            return result.returncode == 0
+        except (FileNotFoundError, subprocess.TimeoutExpired):
+            return False
+
     def _simulate_paste(self) -> None:
         """Simulate Ctrl+V to paste clipboard into non-IBus apps (terminals)."""
         try:
-            if self._ydotool:
+            if self._ydotool and self._ydotoold_running():
                 # ydotool key scancodes: 29=LCtrl, 47=V
                 subprocess.run(
                     [self._ydotool, "key", "29:1", "47:1", "47:0", "29:0"],
@@ -399,7 +411,7 @@ class IBusTyper:
                     capture_output=True, timeout=3,
                 )
             else:
-                log.debug("No paste tool available (ydotool/wtype)")
+                log.debug("No paste tool available (ydotoold not running, wtype not found)")
         except (subprocess.TimeoutExpired, OSError) as e:
             log.debug("Paste simulation failed: %s", e)
 

python_voiceio-0.3.3/voiceio/__init__.py

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