STT slow-internet: extend cloud timeout 3s->15s, reachability 0.5s->3s; add AV-block pill; friendly download pills; hook self-heal cursor-motion gate; yt-dlp logger bridge

Author: sprawf

core/transcriber.py

@@ -447,7 +447,7 @@ def _prewarm_cloud(self) -> None:
             t0 = time.perf_counter()
             sess.get(
                 'https://api.groq.com/openai/v1/models',
-                timeout=3.0,
+                timeout=10.0,
             )
             logger.info(
                 f'Cloud TLS pre-warmed in {(time.perf_counter()-t0)*1000:.0f}ms'
@@ -466,7 +466,7 @@ def _cloud_enabled(self) -> bool:
             return True
 
     def _cloud_reachable(self, host: str = 'api.groq.com',
-                         port: int = 443, timeout: float = 0.5) -> bool:
+                         port: int = 443, timeout: float = 3.0) -> bool:
         """Fast non-blocking TCP probe to detect whether the cloud
         Whisper host is reachable RIGHT NOW. Returns True on successful
         connect, False on any failure (DNS resolution failure, network
@@ -728,9 +728,14 @@ def _transcribe_hybrid(self, audio: np.ndarray):
                         'skipping cloud, going to local.')
             return self._transcribe(audio, _already_denoised=denoised_here)
 
-        # Cloud timeout budget, short, because local is the safety net.
-        # 3 s covers 99 % of Groq calls; anything slower → just go local.
-        cloud_timeout = float(getattr(self._cfg.audio, 'cloud_timeout_s', 3.0))
+        # Cloud timeout budget. Was 3s (too aggressive: users on slow /
+        # rural / congested WiFi never completed the upload phase for a
+        # 2s audio clip before we aborted to local, even when the network
+        # would eventually deliver the response). Bumped to 15s so slow
+        # uploaders on ~20-50 kbps connections still get the higher-
+        # quality Groq result. Local pipeline stays as safety net for
+        # anything slower than that.
+        cloud_timeout = float(getattr(self._cfg.audio, 'cloud_timeout_s', 15.0))
         lang_hint = self._cfg.transcription.language or None
 
         t0 = time.perf_counter()
@@ -768,17 +773,37 @@ def _transcribe_hybrid(self, audio: np.ndarray):
             # AV-blocked / permission-denied / other "cloud reachable but
             # refusing" cases, the local fallback runs transparently and
             # produces a correct result, so we stay silent.
+            exc_name = type(e).__name__.lower()
             if 'name resolution' in msg_l or 'getaddrinfo' in msg_l:
                 self._cloud_last_error = 'Cloud unreachable (DNS) — using local model'
             elif 'connection' in msg_l and ('refus' in msg_l or 'reset' in msg_l):
                 self._cloud_last_error = 'Cloud refused connection — using local model'
             elif 'timeout' in msg_l or 'timed out' in msg_l:
-                self._cloud_last_error = 'Cloud timed out — using local model'
+                # Timeout on slow internet is the most common cause of the
+                # silent "why is my dictation worse" complaint. Make the
+                # cause explicit so the user knows to check connection.
+                self._cloud_last_error = 'Cloud too slow (internet slow?) — used local model'
+            elif (
+                # Antivirus HTTPS interception. AVG / Avast / Kaspersky /
+                # Bitdefender / ESET all MITM outbound TLS by default and
+                # present their own cert, which our TLS stack rejects
+                # because it isn't in truststore. Signature: SSL /
+                # certificate errors, PermissionError 13, "wrong version
+                # number", "unknown ca", "self signed certificate".
+                'ssl' in msg_l or 'certificate' in msg_l
+                or 'winerror 13' in msg_l or 'permission' in exc_name
+                or 'wrong version number' in msg_l or 'unknown ca' in msg_l
+                or 'self signed' in msg_l or 'self-signed' in msg_l
+                or 'cert_' in msg_l
+            ):
+                self._cloud_last_error = (
+                    'Antivirus blocked cloud — add api.groq.com to AV exceptions')
             else:
-                # AV blocks (PermissionError 13), unknown errors, etc:
-                # log for debugging but do not pop a pill — local result
-                # speaks for itself.
-                self._cloud_last_error = None
+                # Unknown errors: still surface something so the user has
+                # a hint. Truncated exception name is enough for us to
+                # diagnose from a screenshot without needing full logs.
+                self._cloud_last_error = (
+                    f'Cloud failed ({type(e).__name__}) — used local model')
             logger.warning(
                 f'Cloud transcription failed in {dt*1000:.0f}ms, falling back '
                 f'to local Whisper. ({type(e).__name__}: {e})'

kbhook.py

@@ -207,6 +207,17 @@ class _LASTINPUTINFO(ctypes.Structure):
 _kernel32 = ctypes.WinDLL('kernel32', use_last_error=True)
 _kernel32.GetTickCount.restype = _wt.DWORD
 
+_user32.GetCursorPos.argtypes = [ctypes.POINTER(_wt.POINT)]
+_user32.GetCursorPos.restype = _wt.BOOL
+
+# Cursor position snapshot from previous is_hook_alive() call. Used to
+# distinguish "input was mouse" (cursor moved) from "input was keyboard"
+# (cursor stationary). GetLastInputInfo reports any input; our hook only
+# sees keyboard, so mouse motion would otherwise falsely mark hook dead.
+_last_cursor_x = 0
+_last_cursor_y = 0
+_last_cursor_check_tick = 0    # GetTickCount ms at prev snapshot
+
 # When True, the hook stops matching/suppressing/dispatching, but still
 # tracks the modifier mask so it can recognise "a registered hotkey was
 # pressed while paused" and tell the app to show a reminder toast.
@@ -447,7 +458,8 @@ def stop() -> None:
 
 # ── Liveness detection + self-heal ────────────────────────────────────────
 
-def is_hook_alive(idle_grace_sec: float = 30.0) -> bool:
+def is_hook_alive(idle_grace_sec: float = 30.0,
+                  min_silent_sec: float = 300.0) -> bool:
     """Return True if the WH_KEYBOARD_LL hook is provably still installed.
 
     Detection approach: compare our own last-hook-callback timestamp
@@ -466,7 +478,16 @@ def is_hook_alive(idle_grace_sec: float = 30.0) -> bool:
       will report dead).
 
     Called from the main.py watchdog loop; must be cheap.
+
+    Mouse-vs-keyboard disambiguation: GetLastInputInfo reports the last
+    time Windows saw ANY input (mouse OR keyboard), but WH_KEYBOARD_LL
+    only sees keyboard. Mouse motion alone would otherwise trip a
+    false-positive every ~2s. We snapshot the cursor position across
+    calls; if the cursor moved between the previous check and now, the
+    recent input includes mouse, so we cannot conclude the hook is dead.
     """
+    global _last_cursor_x, _last_cursor_y, _last_cursor_check_tick
+
     if not _started or _hook_ref[0] is None:
         return False
 
@@ -482,15 +503,46 @@ def is_hook_alive(idle_grace_sec: float = 30.0) -> bool:
     ms_since_windows_input = (now_tick - lii.dwTime) & 0xFFFFFFFF
     sec_since_windows_input = ms_since_windows_input / 1000.0
 
+    # Snapshot cursor now; compare against previous snapshot to see if
+    # mouse moved between checks. Do this BEFORE any early return so the
+    # baseline is fresh for the next call.
+    pt = _wt.POINT()
+    cursor_moved = False
+    if _user32.GetCursorPos(ctypes.byref(pt)):
+        if _last_cursor_check_tick != 0 and (
+            pt.x != _last_cursor_x or pt.y != _last_cursor_y
+        ):
+            cursor_moved = True
+        _last_cursor_x = pt.x
+        _last_cursor_y = pt.y
+        _last_cursor_check_tick = now_tick
+
     if sec_since_windows_input > idle_grace_sec:
         # User is idle. Can't distinguish dead hook from real idleness.
         return True
 
+    if cursor_moved:
+        # Mouse moved since last check — recent input includes mouse
+        # events our keyboard-only hook doesn't see. Can't conclude
+        # anything about hook liveness.
+        return True
+
     sec_since_hook_callback = time.monotonic() - _last_hook_tick
 
-    # Windows saw input in the last N seconds. Our hook must have too
-    # (with a small tolerance for the timestamp race).
-    return sec_since_hook_callback < sec_since_windows_input + 2.0
+    # Even with cursor stationary, mouse CLICKS (button events without
+    # motion) also update GetLastInputInfo but don't fire our keyboard
+    # hook. To avoid tripping on those, require the hook to have been
+    # silent for at least `min_silent_sec` — normal keyboard activity
+    # keeps _last_hook_tick fresh, so 5-min silence combined with recent
+    # OS input is a very reliable "hook is actually dead" signal.
+    if sec_since_hook_callback < min_silent_sec:
+        return True
+
+    # Hook silent for 5+ minutes, cursor stationary between watchdog
+    # ticks, and Windows saw input recently — that input was almost
+    # certainly keyboard (or a mouse click) that our hook should have
+    # seen but didn't. Treat as dead.
+    return False
 
 
 def reinstall_hook() -> bool:

overlay.py

@@ -182,13 +182,27 @@ def show_done(self, elapsed: float) -> None:
 
     # ── URL downloader pills (Ctrl+Alt+D) ────────────────────────────────────
 
+    def show_download_capturing(self) -> None:
+        """Immediate pill shown the instant Ctrl+Alt+D fires, before the
+        clipboard capture completes. Bridges the ~500ms silence between
+        the hotkey press and the download-starting pill."""
+        self._close()
+        self._build('🔍  Reading URL…', _TEXT_CLR, ACCENT)
+
     def show_download_starting(self) -> None:
         """Initial pill — shown the moment the URL is captured, before
         yt-dlp's first progress hook fires (which can take a few seconds
         while it resolves the format manifest)."""
         self._close()
         self._build('📥  Downloading…  0%', _TEXT_CLR, ACCENT)
 
+    def show_download_asking(self) -> None:
+        """Pill shown while the playlist-confirmation dialog is on screen,
+        so the user knows the download is waiting on their input rather
+        than stalled."""
+        self._close()
+        self._build('❓  Playlist detected — choose in dialog', _TEXT_CLR, ACCENT)
+
     def show_download_progress(self, frac: float) -> None:
         """Update the percentage in the in-flight download pill. Safe to
         call from a worker thread via Tk's after()."""

transcribe/youtube.py

@@ -134,6 +134,7 @@ def download_url(
     on_progress: Callable[[float], None] | None = None,
     on_log:      Callable[[str], None]  | None = None,
     on_phase:    Callable[[str], None]  | None = None,
+    allow_playlist: bool = False,
 ) -> Path:
     """User-facing downloader: saves `url` to `dest_dir` using the yt-dlp
     format string `fmt` (see DOWNLOAD_FORMATS for the curated menu). Returns
@@ -145,11 +146,12 @@ def download_url(
     """
     return _download(url, dest_dir, fmt,
                      on_progress=on_progress, on_log=on_log,
-                     on_phase=on_phase)
+                     on_phase=on_phase, allow_playlist=allow_playlist)
 
 
 def _download(url: str, dest_dir, fmt: str, *,
-              on_progress, on_log, on_phase=None) -> Path:
+              on_progress, on_log, on_phase=None,
+              allow_playlist: bool = False) -> Path:
     """on_phase(label) is called with short status strings like 'merging',
     'transcoding', or 'done' so callers can update UI text separately
     from the progress bar."""
@@ -201,12 +203,30 @@ def _pp_hook(d):
         except Exception:
             pass
 
+    # Bridge yt-dlp's internal logger into ours so failures show the
+    # real extractor/HTTP trace in app.log without needing quiet=False
+    # (which would flood the console). Every yt-dlp log line is prefixed
+    # with 'yt-dlp:' so it's greppable.
+    class _YtdlpLogger:
+        def debug(self, msg):
+            # yt-dlp routes both real debug AND normal info through debug()
+            # (an [debug] prefix distinguishes them). We downgrade real
+            # debug lines and keep info at INFO.
+            if msg.startswith('[debug] '):
+                logger.debug(f'yt-dlp: {msg[8:]}')
+            else:
+                logger.info(f'yt-dlp: {msg}')
+        def info(self, msg):     logger.info(f'yt-dlp: {msg}')
+        def warning(self, msg):  logger.warning(f'yt-dlp: {msg}')
+        def error(self, msg):    logger.error(f'yt-dlp: {msg}')
+
     opts = {
         'format':           fmt,
         'outtmpl':          str(dest / '%(title).80s [%(id)s].%(ext)s'),
-        'noplaylist':       True,
+        'noplaylist':       not allow_playlist,
         'quiet':            True,
         'no_warnings':      True,
+        'logger':           _YtdlpLogger(),
         'progress_hooks':   [_hook],
         'postprocessor_hooks': [_pp_hook],
         'extract_flat':     False,