python-voiceio 0.7.1__tar.gz → 0.8.1__tar.gz

{python_voiceio-0.7.1/python_voiceio.egg-info → python_voiceio-0.8.1}/PKG-INFO

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

{python_voiceio-0.7.1 → python_voiceio-0.8.1}/pyproject.toml

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

{python_voiceio-0.7.1 → python_voiceio-0.8.1/python_voiceio.egg-info}/PKG-INFO

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

{python_voiceio-0.7.1 → python_voiceio-0.8.1}/python_voiceio.egg-info/SOURCES.txt

@@ -26,6 +26,7 @@ tests/test_health.py
 tests/test_hints.py
 tests/test_history.py
 tests/test_ibus_pending.py
+tests/test_ibus_ping.py
 tests/test_ibus_typer.py
 tests/test_llm.py
 tests/test_llm_api.py

{python_voiceio-0.7.1 → python_voiceio-0.8.1}/tests/test_app_wiring.py

@@ -274,14 +274,16 @@ class TestEngineLifecycle:
         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)."""
+    def test_idle_engine_death_respawns_without_activation(self):
+        """ibus-daemon reaping a dormant engine must respawn it registered
+        but NEVER activated — the activate/dormant dance grabbed the input
+        source every cycle, and leaving the engine dead let ibus-daemon
+        exec-spawn a socket-stealing duplicate on accidental activation."""
         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()
+        ensure.assert_called_once_with(activate=False)
         assert vio._engine_proc is None
 
     def test_mid_recording_engine_death_recovered(self):
@@ -290,7 +292,7 @@ class TestEngineLifecycle:
         vio._state = _State.RECORDING
         with patch.object(vio, "_ensure_ibus_engine") as ensure:
             vio._check_health()
-        ensure.assert_called_once()
+        ensure.assert_called_once_with()  # default activate=True
 
     def test_single_missed_ping_tolerated(self):
         """One missed ping on a loaded system is not a zombie."""
@@ -310,9 +312,28 @@ class TestEngineLifecycle:
              patch.object(vio, "_health_typer_upkeep"):
             vio._check_health()
             vio._check_health()
-        ensure.assert_called_once()
+        ensure.assert_called_once_with(activate=False)
         proc.kill.assert_called_once()
 
+    def test_dormant_spawn_never_touches_input_source(self):
+        """activate=False must not run `ibus engine voiceio` or gsettings —
+        idle spawns that claimed the source were the focus churn that wiped
+        visible preedits and stole the keyboard mid-typing."""
+        vio, _, _ = _make_vio()
+        with patch("voiceio.app.subprocess.run") as run, \
+             patch("voiceio.app.subprocess.Popen") as popen, \
+             patch.object(vio, "_kill_stale_engine"), \
+             patch("voiceio.ibus.SOCKET_PATH") as sock_path, \
+             patch("voiceio.ibus.READY_PATH"):
+            sock_path.exists.return_value = True
+            run.return_value = MagicMock(returncode=0, stdout="xkb:us::eng\n")
+            vio._spawn_ibus_engine(activate=False)
+        assert vio._engine_proc is not None  # engine process was spawned
+        run_cmds = [c[0][0] for c in run.call_args_list]
+        popen_cmds = [c[0][0] for c in popen.call_args_list if c[0]]
+        assert ["ibus", "engine", "voiceio"] not in run_cmds + popen_cmds
+        assert not any("gsettings" in cmd[0] for cmd in run_cmds + popen_cmds)
+
     def test_successful_ping_resets_counter(self):
         vio, proc = self._vio_ibus(proc_poll=None)
         vio._engine_ping_fails = 1

python_voiceio-0.8.1/tests/test_ibus_ping.py

@@ -0,0 +1,50 @@
+"""Tests for the shared engine ping used by the daemon health watchdog and
+the engine's own refuse-to-double-run guard (a duplicate engine binding the
+socket path silently starves the healthy instance)."""
+from __future__ import annotations
+
+import socket
+import threading
+
+import voiceio.ibus as ibus_mod
+
+
+def test_no_socket_returns_false(tmp_path, monkeypatch):
+    monkeypatch.setattr(ibus_mod, "SOCKET_PATH", tmp_path / "nope.sock")
+    assert ibus_mod.ping_engine(timeout=0.2) is False
+
+
+def test_healthy_peer_answers_pong(tmp_path, monkeypatch):
+    sock_path = tmp_path / "engine.sock"
+    server = socket.socket(socket.AF_UNIX, socket.SOCK_DGRAM)
+    server.bind(str(sock_path))
+    server.settimeout(2.0)
+
+    def _serve():
+        try:
+            data, addr = server.recvfrom(64)
+            if data == b"ping" and addr:
+                server.sendto(b"pong", addr)
+        except OSError:
+            pass
+
+    t = threading.Thread(target=_serve, daemon=True)
+    t.start()
+    monkeypatch.setattr(ibus_mod, "SOCKET_PATH", sock_path)
+    try:
+        assert ibus_mod.ping_engine(timeout=1.0) is True
+    finally:
+        t.join(timeout=2.0)
+        server.close()
+
+
+def test_unresponsive_socket_returns_false(tmp_path, monkeypatch):
+    """A bound-but-silent socket (starved listener) must read as dead."""
+    sock_path = tmp_path / "engine.sock"
+    server = socket.socket(socket.AF_UNIX, socket.SOCK_DGRAM)
+    server.bind(str(sock_path))
+    monkeypatch.setattr(ibus_mod, "SOCKET_PATH", sock_path)
+    try:
+        assert ibus_mod.ping_engine(timeout=0.2) is False
+    finally:
+        server.close()

{python_voiceio-0.7.1 → python_voiceio-0.8.1}/tests/test_robustness.py

@@ -578,6 +578,7 @@ class TestBootRaceAndReProbe:
 
         with patch.dict("os.environ", {
             "DISPLAY": ":0",
+            "XAUTHORITY": "/run/user/1000/.mutter-Xwaylandauth.TEST",
             "WAYLAND_DISPLAY": "wayland-0",
             "XDG_SESSION_TYPE": "wayland",
             "XDG_CURRENT_DESKTOP": "GNOME",
@@ -592,6 +593,34 @@ class TestBootRaceAndReProbe:
 
         app_mod._graphical_env_complete = False
 
+    def test_import_graphical_env_pulls_xauthority(self):
+        """Without the X auth cookie, xclip fails silently inside the daemon
+        and clipboard copies fall back to focus-stealing wl-copy — whose
+        focus-out discards any visible IBus preedit (the flashing preview)."""
+        import os
+
+        from voiceio import app as app_mod
+        from voiceio.app import _import_graphical_env
+
+        app_mod._graphical_env_complete = False
+        env = {
+            "DISPLAY": ":0",
+            "WAYLAND_DISPLAY": "wayland-0",
+            "XDG_SESSION_TYPE": "wayland",
+            "XDG_CURRENT_DESKTOP": "GNOME",
+            "XDG_SESSION_DESKTOP": "gnome",
+        }
+        with patch.dict("os.environ", env, clear=True):
+            with patch(
+                "voiceio.app.subprocess.check_output",
+                return_value="XAUTHORITY=/run/user/1000/.mutter-Xwaylandauth.TEST\n",
+            ):
+                _import_graphical_env()
+            assert os.environ["XAUTHORITY"] == "/run/user/1000/.mutter-Xwaylandauth.TEST"
+            assert app_mod._graphical_env_complete is True
+
+        app_mod._graphical_env_complete = False
+
     def test_try_upgrade_typer_upgrades_from_clipboard_to_ibus(self):
         """When chain has ibus first and current is clipboard, upgrade."""
         vio, _, _ = _make_vio()

{python_voiceio-0.7.1 → python_voiceio-0.8.1}/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.1/voiceio/__init__.py

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

{python_voiceio-0.7.1 → python_voiceio-0.8.1}/voiceio/app.py

@@ -34,6 +34,10 @@ _DEBOUNCE_SECS = 0.8
 # IBus input source configuration.
 _GRAPHICAL_ENV_VARS = (
     "DISPLAY",
+    # Without the X auth cookie, X11 tools (xclip via the XWayland bridge)
+    # fail silently inside the daemon and clipboard copies fall back to
+    # wl-copy — whose focus steal discards any visible IBus preedit.
+    "XAUTHORITY",
     "WAYLAND_DISPLAY",
     "XDG_SESSION_TYPE",
     "XDG_CURRENT_DESKTOP",
@@ -893,7 +897,8 @@ class VoiceIO:
                 return False
             if new_typer.name == "ibus" and self._engine_proc is None:
                 try:
-                    self._ensure_ibus_engine()  # subprocess ops, outside the lock
+                    # subprocess ops, outside the lock; IDLE → never activate
+                    self._ensure_ibus_engine(activate=False)
                 except Exception:
                     log.exception("Upgrade (%s): failed to start IBus engine", reason)
             return True
@@ -919,8 +924,12 @@ class VoiceIO:
         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.
+    def _ensure_ibus_engine(self, activate: bool = True) -> None:
+        """Start the VoiceIO IBus engine, optionally pre-creating its instance.
+
+        ``activate=False`` spawns and registers the engine process without
+        ever touching the input source — the only safe mode while IDLE.
+        Claiming the source (``activate=True``) is reserved for record start.
 
         Single-flight: a concurrent spawn (health loop vs record start)
         is skipped rather than queued — two dances would fight over the
@@ -930,11 +939,11 @@ class VoiceIO:
             log.debug("IBus engine spawn already in progress, skipping")
             return
         try:
-            self._spawn_ibus_engine()
+            self._spawn_ibus_engine(activate)
         finally:
             self._engine_spawn_lock.release()
 
-    def _spawn_ibus_engine(self) -> None:
+    def _spawn_ibus_engine(self, activate: bool = True) -> None:
         from voiceio.ibus import READY_PATH, SOCKET_PATH
         from voiceio.typers.ibus import LAUNCHER_PATH, _ibus_env
 
@@ -984,6 +993,16 @@ class VoiceIO:
                 log.warning("IBus engine started but socket not found, commands may fail")
             return
 
+        if not activate:
+            # Registered-but-dormant mode (health loop, daemon start): the
+            # factory now owns the component name, so ibus-daemon won't
+            # exec-spawn a duplicate engine, and an accidental switch onto
+            # the voiceio source lands on a live pass-through engine. The
+            # engine INSTANCE is created on first activation (record start,
+            # or GNOME switching sources) — no input-source claim needed.
+            log.info("VoiceIO IBus engine ready (registered, dormant)")
+            return
+
         # Remember the source the user is on now so we can return the engine
         # to dormancy without hardcoding index 0 (which may not be the user's
         # keyboard). Phase 2 briefly activates voiceio to spawn the instance.
@@ -1025,22 +1044,12 @@ class VoiceIO:
     def _ping_ibus_engine(self) -> bool:
         """Check if the IBus engine's socket listener is alive.
 
-        Returns True if the engine responds to a ping within 1 second.
         A False result means the engine process is alive but its socket
-        listener / GLib loop is dead (zombie engine).
+        listener is dead or starved (zombie engine) — e.g. a duplicate
+        engine process stole the socket path.
         """
-        import socket as _socket
-        from voiceio.ibus import SOCKET_PATH
-        try:
-            sock = _socket.socket(_socket.AF_UNIX, _socket.SOCK_DGRAM)
-            sock.settimeout(2.0)
-            sock.bind("")
-            sock.sendto(b"ping", str(SOCKET_PATH))
-            data, _ = sock.recvfrom(64)
-            sock.close()
-            return data == b"pong"
-        except (OSError, _socket.timeout):
-            return False
+        from voiceio.ibus import ping_engine
+        return ping_engine(timeout=2.0)
 
     def _detect_input_source_hijack(self) -> None:
         """If the user switched input source away from voiceio mid-recording,
@@ -1084,7 +1093,7 @@ class VoiceIO:
                 try:
                     typer = typer_chain.select(self.platform, self.cfg.output.method)
                     if typer.name == "ibus":
-                        self._ensure_ibus_engine()
+                        self._ensure_ibus_engine(activate=False)
                         return typer
                 except RuntimeError:
                     pass
@@ -1388,20 +1397,30 @@ class VoiceIO:
 
         # 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.
+        # the input source switches away). Respawn it REGISTERED BUT NEVER
+        # ACTIVATED (activate=False): while our factory owns the component
+        # name, ibus-daemon won't exec-spawn a duplicate engine (a duplicate
+        # rebinds the command socket and silently starves the healthy one),
+        # and an accidental switch onto the voiceio source (Super+Space,
+        # GNOME's per-window source memory) lands on a live pass-through
+        # engine instead of a seconds-long cold spawn that eats keystrokes.
+        # Activation — claiming the input source — happens ONLY at record
+        # start: idle activation was the focus churn that wiped visible
+        # preedits and stole the source mid-typing.
         if self._typer.name == "ibus" and self._engine_proc is not None:
             if self._engine_proc.poll() is not None:
                 rc = self._engine_proc.returncode
                 self._engine_proc = None
                 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,
+                    log.info(
+                        "IBus engine exited while dormant (rc=%s) — "
+                        "respawning registered, without activation", rc,
                     )
+                    try:
+                        self._ensure_ibus_engine(activate=False)
+                    except Exception:
+                        log.exception("IBus engine respawn failed")
                 else:
                     log.warning("IBus engine died mid-recording (rc=%s), restarting", rc)
                     try:
@@ -1412,9 +1431,9 @@ class VoiceIO:
             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. One missed ping on a loaded
-                # system is not a zombie — require two consecutive misses.
+                # socket stolen by a duplicate / listener dead) silently
+                # drops all preedit and commit messages. One missed ping on
+                # a loaded system is not a zombie — require two consecutive.
                 if not self._ping_ibus_engine():
                     self._engine_ping_fails += 1
                     if self._engine_ping_fails < 2:
@@ -1432,7 +1451,7 @@ class VoiceIO:
                         pass
                     self._engine_proc = None
                     try:
-                        self._ensure_ibus_engine()
+                        self._ensure_ibus_engine(activate=False)
                         log.info("IBus engine recovered (was zombie)")
                     except Exception:
                         log.exception("IBus engine recovery failed")
@@ -1510,7 +1529,9 @@ class VoiceIO:
                     self._typer.ensure_installed()
             except Exception:
                 log.exception("IBus ensure_installed failed (continuing)")
-            self._ensure_ibus_engine()
+            # Register the engine but never claim the input source at boot —
+            # the instance is created on first activation (record start).
+            self._ensure_ibus_engine(activate=False)
         else:
             # IBus daemon may not be ready at startup (race with graphical
             # session). If IBus is in the preferred chain but wasn't selected,

{python_voiceio-0.7.1 → python_voiceio-0.8.1}/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.8.1/voiceio/ibus/__init__.py

@@ -0,0 +1,33 @@
+"""IBus input method engine for VoiceIO."""
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+SOCKET_PATH = Path(os.environ.get("XDG_RUNTIME_DIR", "/tmp")) / "voiceio-ibus.sock"
+READY_PATH = Path(os.environ.get("XDG_RUNTIME_DIR", "/tmp")) / "voiceio-ibus.ready"
+
+
+def ping_engine(timeout: float = 2.0) -> bool:
+    """True if a live engine answers a ping on SOCKET_PATH.
+
+    Used by the daemon's health watchdog, and by the engine itself at
+    startup to refuse to double-run: a second engine binding the socket
+    path would silently starve the healthy instance (its listener stays
+    blocked on a socket inode that no longer receives anything).
+    """
+    import socket
+
+    if not SOCKET_PATH.exists():
+        return False
+    sock = socket.socket(socket.AF_UNIX, socket.SOCK_DGRAM)
+    try:
+        sock.settimeout(timeout)
+        sock.bind("")  # Linux autobind: gives us an address for the reply
+        sock.sendto(b"ping", str(SOCKET_PATH))
+        data, _ = sock.recvfrom(64)
+        return data == b"pong"
+    except OSError:
+        return False
+    finally:
+        sock.close()

{python_voiceio-0.7.1 → python_voiceio-0.8.1}/voiceio/ibus/engine.py

@@ -24,7 +24,7 @@ import gi
 gi.require_version("IBus", "1.0")
 from gi.repository import GLib, GObject, IBus
 
-from voiceio.ibus import READY_PATH, SOCKET_PATH
+from voiceio.ibus import READY_PATH, SOCKET_PATH, ping_engine
 from voiceio.ibus.pending import PendingBuffer
 
 log = logging.getLogger(__name__)
@@ -146,6 +146,7 @@ def _socket_listener(mainloop: GLib.MainLoop) -> None:
         except socket.timeout:
             continue
         except OSError:
+            log.exception("Socket listener error — listener exiting")
             break
 
         msg = data.decode("utf-8", errors="replace")
@@ -229,6 +230,15 @@ def main() -> None:
         ],
     )
 
+    # Refuse to double-run. ibus-daemon can exec-spawn its own copy of this
+    # engine (component XML) when something activates the voiceio source —
+    # e.g. GNOME's per-window source memory. Binding SOCKET_PATH here would
+    # steal it from the healthy daemon-spawned engine and silently starve it
+    # (alive, but never sees another command or ping → zombie recovery).
+    if ping_engine(timeout=0.5):
+        log.info("Healthy VoiceIO engine already serving %s — exiting duplicate", SOCKET_PATH)
+        return
+
     IBus.init()
     bus = IBus.Bus()