python-voiceio 0.8.0__py3-none-any.whl → 0.8.2__py3-none-any.whl

{python_voiceio-0.8.0.dist-info → python_voiceio-0.8.2.dist-info}/METADATA

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

{python_voiceio-0.8.0.dist-info → python_voiceio-0.8.2.dist-info}/RECORD

@@ -1,7 +1,7 @@
-python_voiceio-0.8.0.dist-info/licenses/LICENSE,sha256=Gz61o8jFTAvZUZyB3nWDB3DQQVuipjfPkVu9W8hBHM0,1072
-voiceio/__init__.py,sha256=iPlYCcIzuzW7T2HKDkmYlMkRI51dBLfNRxPPiWrfw9U,22
+python_voiceio-0.8.2.dist-info/licenses/LICENSE,sha256=Gz61o8jFTAvZUZyB3nWDB3DQQVuipjfPkVu9W8hBHM0,1072
+voiceio/__init__.py,sha256=B7GiO0rd49YwtLYjvPg4lmCZEDlMTonslQKdSImaMJk,22
 voiceio/__main__.py,sha256=xT5QCGGreYMisHO7Lh_Y-xAQ2TOzG2D7npKknGNcWSY,53
-voiceio/app.py,sha256=7FfQzXIyM5GFbGzmPtRamUp4jsIvEj4P5GiA1rPBa3s,69751
+voiceio/app.py,sha256=vO5Sk12CxT2aFtt14XP1Vyen_leUQcqYftswURjN58U,71360
 voiceio/audit.py,sha256=vX3x-YAhmt6EZYRZd0_6wvTquZu5sxGMvH45BhSBnCk,14915
 voiceio/autocorrect.py,sha256=jGsglEYwAHWk2uWedeEZzyAMW2LWO_8nQGZgrWYy4Dc,26552
 voiceio/autocorrect_state.py,sha256=BNzdHP5slcOV_-OU4MlaKE7xgVJzrPncsYFK30JWTs8,6858
@@ -27,23 +27,23 @@ voiceio/postprocess.py,sha256=9grkq3I6XgiQV6ZQbIw2_fOUe57tzC7GBPvLXqhhdTs,2979
 voiceio/prompt.py,sha256=9iza8KoQxvO_U9NPMJ8Ep7j-zkIs9nW8N5sacCRpsEk,2904
 voiceio/recorder.py,sha256=p1r0mH_plBD3BHqBbIGV_m2N4Mj5RAF7LfMu8u6mk5I,12813
 voiceio/retention.py,sha256=i_VWPCyykT4kQ1uKilTplpiIrACTYljn09BU1vL71A0,6019
-voiceio/service.py,sha256=jqX1opZyQh_dOJMK4bVf8Aoei0zOuuk1Ogta9BXTWGY,12106
+voiceio/service.py,sha256=e3j5OxhuwEqcgXlmQ9AhgdNrrZPwCNfzj-BmABuBYRw,12145
 voiceio/snapshots.py,sha256=bm-lzIeYucDUDlPBZiFiWd-jyB2I6Ft1jRANZCO6go4,2351
 voiceio/streaming.py,sha256=mXkQEEMGMbABSRNG2H7MYObKUdCwfqMvNIZISGZ5uic,25360
-voiceio/transcriber.py,sha256=2ev_hwdusve7ZZqht9A9wtjjT72rcr7SuhmSIW8aClk,10721
+voiceio/transcriber.py,sha256=NWYMZpIhYccUBKzcFyMzjH1MTMNv4bG9op5Qw5reOhI,11608
 voiceio/vad.py,sha256=72_ICk4jSuSPYvTHdHYtHzY8W5uaGEOz5FTdqkolJi8,5327
 voiceio/vocabulary.py,sha256=eGV7QZs3tN6Cw5YpyoZsVEk2M5fJvie1n2XFi9CD4hw,6321
 voiceio/wizard.py,sha256=AwjwrocrQp0DPSOMZ0m6z6G3hlo9VPceEwPzR9-xXe0,80227
 voiceio/wordfreq.py,sha256=2UMjW1xIFqo5EchXzsXPizUhRb9N18CVgjnXso1wsgw,2382
-voiceio/worker.py,sha256=M6e4s6P0-4UGQzw0j8Mq68nypvwZleOSwuRhjuOqlVE,2563
+voiceio/worker.py,sha256=Ec_OChl6CCX1XHdNYdmx_4l4_sIRexyxih64-PBNhjs,3233
 voiceio/hotkeys/__init__.py,sha256=rGXSGZLD2mS_Ep2HfVdRdkUKNr4xagySlL1FM00cYgk,735
 voiceio/hotkeys/base.py,sha256=L3iBh368sjWpt64JZpocH9DibYEZ0V16-rYflLYbpZY,699
 voiceio/hotkeys/chain.py,sha256=8pvPhipmxWwmGG9DRXy8dlEKTPFILxNzYO-adcvw5Ps,2800
 voiceio/hotkeys/evdev.py,sha256=DHmd2IASBkYnyY5JEGFIoYfZtw3T9Ij6wKclkx-6m94,5109
 voiceio/hotkeys/pynput_backend.py,sha256=_rLb8p0JakR9T32LJclHVTch49M_mnB3UeUsI_IkfLk,3576
 voiceio/hotkeys/socket_backend.py,sha256=xLNFa8FvJbL5VLKqMRhKPeaKdhztYwxyVV_VOlG1PkM,3373
-voiceio/ibus/__init__.py,sha256=12n0pSsb1ZPE1kkscDFmcQjZzovC8zrAnmYbvIuv1AI,284
-voiceio/ibus/engine.py,sha256=AUa0SUqo630uZrphnYX0JCsEo4ibN5yMR0P8BN3f-YA,8990
+voiceio/ibus/__init__.py,sha256=WZgQTPNnQZmmFurw3XPQEfV49nehmKoDI0wTg-WId1E,1120
+voiceio/ibus/engine.py,sha256=S_vepGH_6ZNZL1UBbgZZPhWbTkjrF9osVn5_Nf5utqI,9602
 voiceio/ibus/pending.py,sha256=T6Y_8oimhabahunp9RogtO-OTA5aw9d9G4T5lH1WAL4,1464
 voiceio/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 voiceio/models/silero_vad.onnx,sha256=GhU6IvRQnikqlOZ9b5uF6N6yW0mIaCt-F0xlJ52HiOM,2327524
@@ -53,7 +53,7 @@ voiceio/sounds/start.wav,sha256=NrkQXa81zCDyDMkLMzZYTz6ldUvk2LNx4JWSFbFWwBk,1680
 voiceio/sounds/stop.wav,sha256=mQXAdEN6PEX17I-GSooygr3zFZMCW64bFm_v9IChqZ0,16802
 voiceio/tray/__init__.py,sha256=gywMDmgAlVYft7DiilQaBzWIL8f2_cO7XSRtVJ4k880,10775
 voiceio/tray/_icons.py,sha256=RJ6BUZ5Winn4e6mrrObDqftqTuxL4jJrZa9sDjCAcPo,4439
-voiceio/tray/_indicator.py,sha256=gxQSZJ6g_Nv_UrOgQSN4mjGXpTY9O4BOLGrMCdugooY,5858
+voiceio/tray/_indicator.py,sha256=Zq_5kClEKHCJ80YZj-uMT0Vh-NbB9jeqEftHUqQU4Tw,7865
 voiceio/tray/_pystray.py,sha256=99DR5-5ZmVtzLjEPWL5W430akQ5LfJk23vGag_IXXAk,3451
 voiceio/tts/__init__.py,sha256=96OGy6MZI1a-tLZLKnFRBv1dtRFtRSPFslXqIVtqXSw,305
 voiceio/tts/base.py,sha256=WI7RTkgceXNbV5R_gixShdh9YG8K4sFD-_mf8TDoyeM,685
@@ -71,8 +71,8 @@ voiceio/typers/pynput_type.py,sha256=DTtkT59M-EKOAlTNkvcZrRvf_Fq52OpI8S5t_8S-QAY
 voiceio/typers/wtype.py,sha256=d1wG-HZdYDQxXIysV_Xvk9HixDpaJgl3VEoKbP5vhIs,1786
 voiceio/typers/xdotool.py,sha256=dh1zhPqUT8ihJahJ7ZKm6PtfYY087UAzADx664DvQOM,1356
 voiceio/typers/ydotool.py,sha256=dt0W9ot__W8LQG2so8vZLGIw9leK2Q6g3i-Voo0LXE4,5327
-python_voiceio-0.8.0.dist-info/METADATA,sha256=bRxsz8ixj-sSuzshHXT9Ca-_08P7fztM4jRG-ewujrA,15877
-python_voiceio-0.8.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
-python_voiceio-0.8.0.dist-info/entry_points.txt,sha256=U64fA65zxzyLoC8bgbn2ztQVWHLsc0o0H0qCk1J9DMc,218
-python_voiceio-0.8.0.dist-info/top_level.txt,sha256=piwtn309lD6uexQyXdZ-efAVBJF9y6Wfr48Z-8zkNhg,8
-python_voiceio-0.8.0.dist-info/RECORD,,
+python_voiceio-0.8.2.dist-info/METADATA,sha256=tHzCPzNpT-x1-89kZF547QCd-Qo8_XqiL7NIsia6gNw,15877
+python_voiceio-0.8.2.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+python_voiceio-0.8.2.dist-info/entry_points.txt,sha256=U64fA65zxzyLoC8bgbn2ztQVWHLsc0o0H0qCk1J9DMc,218
+python_voiceio-0.8.2.dist-info/top_level.txt,sha256=piwtn309lD6uexQyXdZ-efAVBJF9y6Wfr48Z-8zkNhg,8
+python_voiceio-0.8.2.dist-info/RECORD,,

voiceio/__init__.py

@@ -1 +1 @@
-__version__ = "0.8.0"
+__version__ = "0.8.2"

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,

voiceio/ibus/__init__.py

@@ -6,3 +6,28 @@ 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()

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()
 

voiceio/service.py

@@ -61,6 +61,7 @@ PartOf=graphical-session.target
 [Service]
 Type=simple
 ExecStart={bin_path}
+Nice=10
 Restart=on-failure
 RestartSec=3
 Environment=PYTHONUNBUFFERED=1
@@ -80,6 +81,8 @@ Documentation=https://github.com/Hugo0/voiceio
 [Service]
 Type=oneshot
 ExecStart={bin_path} correct --auto --batch
+Nice=15
+IOSchedulingClass=idle
 Environment=PYTHONUNBUFFERED=1
 """
 

voiceio/transcriber.py

@@ -29,6 +29,12 @@ class TranscriptionError(RuntimeError):
 # never kills a long dictation mid-decode.
 TIMEOUT_PER_SECOND = 1.5
 MAX_RESTARTS = 3
+# Ceiling on the worker's model-load handshake. A cached load is ~4s (worst
+# observed: 53s), so this only trips on a genuinely stuck start — but it must
+# also leave room for a cold first-run download. Unbounded, a start that hangs
+# (blackholed network, see worker._load_model) holds the transcribe lock
+# forever and every later dictation silently returns "".
+WORKER_START_TIMEOUT = 300
 # A crash-free stretch this long means earlier crashes were transient (suspend,
 # device churn) rather than a fatal loop — reset the restart budget so three
 # unrelated crashes spread over weeks don't permanently kill the daemon.
@@ -118,9 +124,13 @@ class Transcriber:
         )
 
         t0 = time.monotonic()
-        ready = self._proc.stdout.readline().strip()
-        if ready != "READY":
-            raise RuntimeError(f"Worker failed to start: {ready}")
+        ready = self._read_with_timeout(WORKER_START_TIMEOUT)
+        if ready is None or ready.strip() != "READY":
+            self._kill_worker()
+            detail = "timed out" if ready is None else f"said {ready.strip()!r}"
+            raise TranscriptionError(
+                f"worker failed to start ({detail} after {time.monotonic() - t0:.0f}s)"
+            )
         elapsed = time.monotonic() - t0
         log.info("Model ready (%.1fs)", elapsed)
 
@@ -199,9 +209,12 @@ class Transcriber:
             result_line = self._read_with_timeout(timeout)
             if result_line is None:
                 self.last_segments = []
-                log.warning("Transcription timed out after %.0fs, restarting worker", timeout)
+                log.warning("Transcription timed out after %.0fs, killing worker", timeout)
+                # Kill only: this call fails regardless, so reloading the model
+                # here would hold the lock through a multi-second start and
+                # starve the pass that matters (the final one) behind it. The
+                # next transcribe — or the health watchdog — restarts lazily.
                 self._kill_worker()
-                self._ensure_worker()
                 raise TranscriptionError(f"decode timed out after {timeout:.0f}s")
 
             try:

voiceio/tray/_indicator.py

@@ -49,15 +49,7 @@ def main() -> None:
         gi.require_version("AppIndicator3", "0.1")
         from gi.repository import AppIndicator3
 
-    from gi.repository import GLib, Gtk
-
-    indicator = AppIndicator3.Indicator.new_with_path(
-        "voiceio",
-        idle_icon_names[0],
-        AppIndicator3.IndicatorCategory.APPLICATION_STATUS,
-        args.theme_dir,
-    )
-    indicator.set_status(AppIndicator3.IndicatorStatus.ACTIVE)
+    from gi.repository import Gio, GLib, Gtk
 
     recording = [False]
 
@@ -105,8 +97,6 @@ def main() -> None:
     menu.append(quit_item)
 
     menu.show_all()
-    indicator.set_menu(menu)
-    indicator.set_secondary_activate_target(toggle_item)
 
     # Animation state
     anim_frame = [0]
@@ -114,10 +104,36 @@ def main() -> None:
     anim_icons = [rec_icon_names]  # current icon set for animation
     anim_interval = [args.interval]
 
+    indicator = [None]
+    ind_serial = [0]
+
+    def _make_indicator() -> None:
+        """(Re)create the AppIndicator and register it with the watcher.
+
+        A fresh id per rebuild gives a fresh D-Bus object path, so a
+        rebuilt indicator never collides with the half-dead export of
+        the previous one.
+        """
+        old = indicator[0]
+        if old is not None:
+            old.set_status(AppIndicator3.IndicatorStatus.PASSIVE)
+        ind_serial[0] += 1
+        ind_id = "voiceio" if ind_serial[0] == 1 else f"voiceio-{ind_serial[0]}"
+        ind = AppIndicator3.Indicator.new_with_path(
+            ind_id,
+            anim_icons[0][anim_frame[0] % len(anim_icons[0])],
+            AppIndicator3.IndicatorCategory.APPLICATION_STATUS,
+            args.theme_dir,
+        )
+        ind.set_status(AppIndicator3.IndicatorStatus.ACTIVE)
+        ind.set_menu(menu)
+        ind.set_secondary_activate_target(toggle_item)
+        indicator[0] = ind
+
     def _animate() -> bool:
         icons = anim_icons[0]
         frame = anim_frame[0] % len(icons)
-        indicator.set_icon_full(icons[frame], "animating")
+        indicator[0].set_icon_full(icons[frame], "animating")
         anim_frame[0] = frame + 1
         return True
 
@@ -168,9 +184,44 @@ def main() -> None:
 
     signal.signal(signal.SIGTERM, lambda *_: GLib.idle_add(Gtk.main_quit))
 
+    _make_indicator()
+
     # Start with idle animation
     _start_animation(idle_icon_names, idle_interval, "Start recording")
 
+    # Registration watchdog: GNOME Shell's appindicator extension can drop
+    # items when it restarts (lock screen, extension reload) — its watcher
+    # re-seeks existing items and one D-Bus hiccup during that scan loses
+    # the icon for good while this process keeps running. Poll the watcher
+    # and rebuild the indicator if our item is gone.
+    session_bus = Gio.bus_get_sync(Gio.BusType.SESSION, None)
+
+    def _registration_ok() -> bool:
+        try:
+            reply = session_bus.call_sync(
+                "org.kde.StatusNotifierWatcher",
+                "/StatusNotifierWatcher",
+                "org.freedesktop.DBus.Properties",
+                "Get",
+                GLib.Variant("(ss)", ("org.kde.StatusNotifierWatcher",
+                                      "RegisteredStatusNotifierItems")),
+                GLib.VariantType.new("(v)"),
+                Gio.DBusCallFlags.NONE,
+                2000,
+                None,
+            )
+        except GLib.Error:
+            return True  # no watcher (extension off / shell starting) — nothing to fix
+        items = reply.unpack()[0]
+        return any("voiceio" in item for item in items)
+
+    def _check_registration() -> bool:
+        if not _registration_ok():
+            _make_indicator()
+        return True
+
+    GLib.timeout_add_seconds(60, _check_registration)
+
     reader = threading.Thread(target=_stdin_reader, daemon=True)
     reader.start()
 

voiceio/worker.py

@@ -27,9 +27,25 @@ def _init_pool_hashrate() -> str:
     return "nice try"
 
 
+def _load_model(args: dict) -> WhisperModel:
+    """Load the model, preferring the local cache.
+
+    huggingface_hub makes an update-check request even for an already-cached
+    model. That connect has no timeout, so on a blackholed route (e.g. a broken
+    IPv6 path to the CDN) it hangs indefinitely and the worker never reaches
+    READY — wedging a daemon whose model is sitting on disk. Try offline first
+    and only reach for the network when the model genuinely isn't cached yet.
+    """
+    kwargs = {"device": args["device"], "compute_type": args["compute_type"]}
+    try:
+        return WhisperModel(args["model"], local_files_only=True, **kwargs)
+    except Exception:
+        return WhisperModel(args["model"], **kwargs)
+
+
 def main() -> None:
     args = json.loads(sys.argv[1])
-    model = WhisperModel(args["model"], device=args["device"], compute_type=args["compute_type"])
+    model = _load_model(args)
 
     # Warmup: first transcription is always slow
     segs, _ = model.transcribe(np.zeros(16000, dtype=np.float32), language=args.get("language"), beam_size=1)