python-voiceio 1.15.2__tar.gz → 1.16.1__tar.gz

{python_voiceio-1.15.2/python_voiceio.egg-info → python_voiceio-1.16.1}/PKG-INFO

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

{python_voiceio-1.15.2 → python_voiceio-1.16.1}/pyproject.toml

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

{python_voiceio-1.15.2 → python_voiceio-1.16.1/python_voiceio.egg-info}/PKG-INFO

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

{python_voiceio-1.15.2 → python_voiceio-1.16.1}/python_voiceio.egg-info/SOURCES.txt

@@ -29,6 +29,7 @@ tests/test_fallback.py
 tests/test_fcitx_bridge.py
 tests/test_feedback_stream.py
 tests/test_focus.py
+tests/test_gpu_fallback.py
 tests/test_health.py
 tests/test_hints.py
 tests/test_history.py

python_voiceio-1.16.1/tests/test_gpu_fallback.py

@@ -0,0 +1,80 @@
+"""device = "auto" with a GPU whose CUDA libraries are missing: CPU, not a crash loop."""
+from __future__ import annotations
+
+import sys
+from types import SimpleNamespace
+from unittest.mock import patch
+
+import pytest
+
+worker = pytest.importorskip("voiceio.core.decoders.faster_whisper.worker")
+
+ARGS = {"model": "small", "compute_type": "int8", "language": "en"}
+
+
+def _loader(fail_on: set[str]):
+    devices = []
+
+    def load(args, device):
+        devices.append(device)
+        if device in fail_on:
+            raise RuntimeError("Library libcublas.so.12 is not found or cannot be loaded")
+        return SimpleNamespace(device=device)
+    return load, devices
+
+
+def test_auto_falls_back_to_cpu_when_cuda_fails_at_first_encode(capsys):
+    load, devices = _loader({"auto"})
+    with patch.object(worker, "_load_and_warm", load):
+        model, why = worker.load_ready({**ARGS, "device": "auto"})
+    assert model.device == "cpu" and devices == ["auto", "cpu"]
+    assert "libcublas.so.12" in why
+    assert "decoding on CPU" in capsys.readouterr().err
+
+
+def test_explicit_cuda_still_fails_loudly():
+    load, _ = _loader({"cuda"})
+    with patch.object(worker, "_load_and_warm", load), pytest.raises(RuntimeError):
+        worker.load_ready({**ARGS, "device": "cuda"})
+
+
+def test_working_device_reports_no_fallback():
+    load, devices = _loader(set())
+    with patch.object(worker, "_load_and_warm", load):
+        assert worker.load_ready({**ARGS, "device": "auto"})[1] == ""
+    assert devices == ["auto"]
+
+
+def test_doctor_names_missing_cuda_libs(monkeypatch):
+    from voiceio import health
+    from voiceio.config import Config
+    cfg = Config()
+    cfg.model.name, cfg.model.device = "small", "auto"
+    monkeypatch.setattr("voiceio.config.load", lambda: cfg)
+    monkeypatch.setitem(sys.modules, "ctranslate2",
+                        SimpleNamespace(get_cuda_device_count=lambda: 1))
+    real = __import__("ctypes").CDLL
+
+    def cdll(name, *a, **k):
+        if name == "libcublas.so.12":
+            raise OSError(name)
+        return real("libc.so.6")
+    monkeypatch.setattr("ctypes.CDLL", cdll)
+    msg = health._gpu_libs_warning()
+    assert "libcublas.so.12" in msg and "libcudnn" not in msg and 'model.device = "cpu"' in msg
+    cfg.model.device = "cpu"
+    assert health._gpu_libs_warning() == ""
+
+
+def test_daemon_accepts_the_fallback_handshake_and_logs_it(caplog):
+    from unittest.mock import MagicMock
+
+    from voiceio.config import ModelConfig
+    from voiceio.core.decoders.faster_whisper import Transcriber
+    proc = MagicMock()
+    proc.stdout.readline.return_value = "READY cpu-fallback: libcublas.so.12 missing\n"
+    proc.poll.return_value = None
+    with patch("voiceio.core.decoders.faster_whisper.subprocess.Popen", return_value=proc), \
+         caplog.at_level("WARNING"):
+        Transcriber(ModelConfig())
+    assert "decoding on CPU instead: libcublas.so.12 missing" in caplog.text

{python_voiceio-1.15.2 → python_voiceio-1.16.1}/tests/test_health.py

@@ -149,3 +149,16 @@ def test_check_ibus_asks_about_voiceio_only_when_the_engine_is_silent():
             alive.reset_mock()
             assert health._check_ibus().voiceio_running is True
             alive.assert_not_called()
+
+
+def test_kde_wayland_without_ibus_input_method_warns(tmp_path):
+    from voiceio.health import _kde_input_method_warning
+    kde = Platform(os="linux", display_server="wayland", desktop="kde")
+    rc = tmp_path / "kwinrc"
+    rc.write_text("[Wayland]\nInputMethod[$e]=/usr/share/applications/com.github.maliit.keyboard.desktop\n")
+    assert "Virtual Keyboard" in _kde_input_method_warning(kde, rc)
+    rc.write_text("[Wayland]\nInputMethod[$e]=/usr/share/applications/org.freedesktop.IBus.Panel.Wayland.Gtk3.desktop\n")
+    assert _kde_input_method_warning(kde, rc) == ""
+    assert "Virtual Keyboard" in _kde_input_method_warning(kde, tmp_path / "missing")
+    gnome = Platform(os="linux", display_server="wayland", desktop="gnome")
+    assert _kde_input_method_warning(gnome, tmp_path / "missing") == ""

{python_voiceio-1.15.2 → python_voiceio-1.16.1}/tests/test_report.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 import io
 import json
 import sys
+from pathlib import Path
 
 import pytest
 
@@ -96,12 +97,12 @@ def test_report_contains_only_backend_and_model_names(identity):
 def test_report_lists_failures_and_warnings():
     health = _health(typer_backends=[BackendStatus("ibus", False, "daemon down")],
                      cli_in_path=False, tray_ok=False, tray_reason="no AppIndicator")
-    text = report.build_report(health, missing_deps=["portaudio"], perm_issues=2, cfg=Config())
+    text = report.build_report(health, missing_deps=["portaudio"], perm_issues=[Path(FAKE_HOME) / ".config/voiceio/config.toml"], cfg=Config())
     assert "typer none" in text
     assert "typer ibus: daemon down" in text
     assert "missing system deps" in text
     assert "cli not in PATH" in text and "tray: no AppIndicator" in text
-    assert "insecure permissions on 2 file(s)" in text
+    assert "insecure permissions on ~/.config/voiceio/config.toml" in text
 
 
 def test_silent_ibus_engine_is_expected_while_voiceio_is_stopped():
@@ -109,9 +110,9 @@ def test_silent_ibus_engine_is_expected_while_voiceio_is_stopped():
     ib = IBusStatus(component_installed=True, daemon_running=True, env_persisted=True)
     stopped = report.build_report(_health(ibus_checks=IBusStatus(**{**vars(ib), "voiceio_running": False})),
                                   cfg=Config())
-    assert "engine ping" not in stopped and "voiceio not running" in stopped
+    assert "engine ping" not in stopped and "voiceio was not running when this report was made" in stopped
     running = report.build_report(_health(ibus_checks=ib), cfg=Config())
-    assert "ibus engine ping" in running and "voiceio not running" not in running
+    assert "ibus engine ping" in running and "not running" not in running
 
 
 def test_comment_is_one_bounded_line():
@@ -121,6 +122,34 @@ def test_comment_is_one_bounded_line():
     assert len(line) <= len("comment: ") + report.MAX_COMMENT
 
 
+def test_long_comment_ends_with_an_ellipsis_at_a_word():
+    text = report.build_report(_health(), comment="word " * 400, cfg=Config())
+    line = next(ln for ln in text.splitlines() if ln.startswith("comment:"))
+    assert line.endswith("word…") and len(line) <= len("comment: ") + report.MAX_COMMENT
+    short = report.build_report(_health(), comment="fine " * 100, cfg=Config())
+    assert "…" not in short
+
+
+def test_works_line_only_for_a_known_answer():
+    assert "works: no" in report.build_report(_health(), works="no", cfg=Config()).splitlines()
+    assert "works:" not in report.build_report(_health(), works="maybe", cfg=Config())
+
+
+def test_many_insecure_paths_are_counted(identity):
+    paths = [Path(FAKE_HOME) / f"f{i}" for i in range(7)]
+    text = report.build_report(_health(), perm_issues=paths, cfg=Config())
+    assert "~/f0, ~/f1, ~/f2, ~/f3, ~/f4 and 2 more" in text
+    _assert_private(text)
+
+
+def test_ask_details_maps_answers(monkeypatch):
+    answers = iter(["  it typed twice  ", "Y"])
+    monkeypatch.setattr(report, "_ask", lambda prompt: next(answers))
+    assert report.ask_details() == ("it typed twice", "yes")
+    answers = iter(["", "whatever"])
+    assert report.ask_details() == ("", "")
+
+
 def test_comment_drops_terminal_escapes():
     # A real 1.15.0 report arrived with "comment: \x1bv" (Alt+V at the prompt).
     text = report.build_report(_health(), comment="\x1bv", cfg=Config())

{python_voiceio-1.15.2 → python_voiceio-1.16.1}/tests/test_service.py

@@ -96,6 +96,25 @@ def test_daemon_publishes_state_and_restart_waits_for_idle(monkeypatch):
     assert not wait_until_idle(timeout=60, poll=0.05, finalizing_timeout=0.2)
 
 
+def test_restart_after_a_long_recording_still_waits_for_its_finalize(monkeypatch):
+    """The finalize budget counts from when finalizing starts: a recording
+    longer than it must not make the restart skip the finalize (11-02)."""
+    import threading
+
+    from voiceio import config, pidlock
+    from voiceio.app import VoiceIO, _State
+    from voiceio.cli.servicecmd import wait_until_idle
+
+    vio = VoiceIO.__new__(VoiceIO)
+    vio._publishes_state = True
+    vio._state = _State.RECORDING
+    monkeypatch.setattr(pidlock, "daemon_alive", lambda path: True)
+    threading.Timer(0.4, lambda: setattr(vio, "_state", _State.FINALIZING)).start()
+    threading.Timer(0.7, lambda: setattr(vio, "_state", _State.IDLE)).start()
+    assert wait_until_idle(timeout=5, poll=0.05, finalizing_timeout=0.5)
+    assert config.STATE_PATH.read_text() == "idle"
+
+
 def test_daemon_alive_probes_the_pid_lock(tmp_path):
     import fcntl
 
@@ -168,3 +187,29 @@ def test_reinstalling_the_service_refreshes_learning_units_that_are_on(monkeypat
     monkeypatch.setattr(service, "refresh_learn_timer", lambda: calls.append("refresh"))
     monkeypatch.setattr(service.subprocess, "run", lambda *a, **k: None)
     assert service.install_service() and calls == ["refresh"]
+
+
+def test_slow_daemon_reload_still_enables_the_service(tmp_path, monkeypatch):
+    # Mint report: daemon-reload hit its 5s timeout and setup never ran enable.
+    import subprocess
+    from voiceio import service
+    monkeypatch.setattr(service, "has_systemd", lambda: True)
+    monkeypatch.setattr(service, "_find_voiceio_bin", lambda: "voiceio")
+    monkeypatch.setattr(service, "SERVICE_DIR", tmp_path)
+    monkeypatch.setattr(service, "SERVICE_PATH", tmp_path / service.SERVICE_NAME)
+    for name in ("install_symlinks", "uninstall_correct_timer", "refresh_learn_timer"):
+        monkeypatch.setattr(service, name, lambda: None)
+    ran = []
+
+    def run(cmd, **kw):
+        ran.append(cmd[2])
+        assert kw["timeout"] == service.SYSTEMCTL_TIMEOUT
+        if cmd[2] == "daemon-reload":
+            raise subprocess.TimeoutExpired(cmd, kw["timeout"])
+        return subprocess.CompletedProcess(cmd, 1 if cmd[2] == enable_fails else 0)
+    monkeypatch.setattr(service.subprocess, "run", run)
+    enable_fails = None
+    assert service.install_service()
+    assert ran == ["daemon-reload", "disable", "enable"]
+    enable_fails = "enable"
+    assert not service.install_service()

python_voiceio-1.16.1/voiceio/__init__.py

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

{python_voiceio-1.15.2 → python_voiceio-1.16.1}/voiceio/app.py

@@ -1076,6 +1076,10 @@ class VoiceIO:
                 self._tts_engine.shutdown()
             self._idle_audio.shutdown()
             self.recorder.close_stream()
+            # Lets a cue still playing finish: PortAudio torn down at exit
+            # under a write corrupts the heap (ABRT on stop after a dictation).
+            from voiceio import feedback
+            feedback.close_cue_stream()
             self._quiet.close()
             self.decoder.close()
             tray.stop()

{python_voiceio-1.15.2 → python_voiceio-1.16.1}/voiceio/cli/doctor.py

@@ -87,7 +87,7 @@ def _cmd_doctor(args: argparse.Namespace) -> None:
         from voiceio.hints import hint
         hint("vocab_suggest", "Run 'voiceio vocab suggest' to find names it keeps mishearing")
         if args.report:
-            _share_report(args, report, missing_deps, len(perm_issues))
+            _share_report(args, report, missing_deps, [p for p, _, _ in perm_issues])
         sys.exit(0 if (report.all_ok and not perm_issues and not missing_deps) else 1)
 
     # Auto-fix mode
@@ -199,16 +199,19 @@ def _cmd_doctor(args: argparse.Namespace) -> None:
 
     if args.report:
         _share_report(args, report, plat.check_system_deps(),
-                      len(_config.check_permissions()))
+                      [p for p, _, _ in _config.check_permissions()])
     sys.exit(0 if report.all_ok else 1)
 
 
 def _share_report(args: argparse.Namespace, report, missing_deps: list[str],
-                  perm_issues: int) -> None:
-    from voiceio.report import build_report, share
+                  perm_issues: list) -> None:
+    from voiceio.report import _interactive, ask_details, build_report, share
+    comment, works = args.comment or "", ""
+    if not comment and not args.yes and _interactive():
+        comment, works = ask_details()
     try:
         text = build_report(report, missing_deps=missing_deps, perm_issues=perm_issues,
-                            comment=args.comment or "")
+                            comment=comment, works=works)
     except Exception as e:  # noqa: BLE001 — the report must not take doctor down
         print(f"\nCould not build the report ({type(e).__name__}); nothing was posted.")
         return

{python_voiceio-1.15.2 → python_voiceio-1.16.1}/voiceio/cli/servicecmd.py

@@ -96,6 +96,7 @@ def wait_until_idle(timeout: float = 300.0, poll: float = 0.25,
     from voiceio.config import PID_PATH, STATE_PATH
     from voiceio.pidlock import daemon_alive
     start, told = time.monotonic(), False
+    seen, since = None, start
     try:
         while True:
             if not daemon_alive(PID_PATH):
@@ -106,8 +107,13 @@ def wait_until_idle(timeout: float = 300.0, poll: float = 0.25,
                 return True      # pre-1.1 daemon: nothing to wait for
             if state in ("idle", "error"):
                 return True
-            waited = time.monotonic() - start
-            if waited > (finalizing_timeout if state == "finalizing" else timeout):
+            now = time.monotonic()
+            if state != seen:
+                seen, since = state, now
+            # A finalize's budget starts when it does: after a long recording
+            # the total wait already exceeds it.
+            if (now - since > finalizing_timeout if state == "finalizing"
+                    else now - start > timeout):
                 print(f"Still {state}; going ahead. (--now skips the wait.)", file=sys.stderr)
                 return False
             if not told:

{python_voiceio-1.15.2 → python_voiceio-1.16.1}/voiceio/core/decoders/faster_whisper/__init__.py

@@ -134,12 +134,16 @@ class Transcriber:
 
         t0 = time.monotonic()
         ready = self._read_with_timeout(WORKER_START_TIMEOUT)
-        if ready is None or ready.strip() != "READY":
+        if ready is None or ready.split(" ", 1)[0].strip() != "READY":
             self._kill_worker()
             detail = "timed out" if ready is None else f"said {ready.strip()!r}"
             raise DecodeError(
                 f"worker failed to start ({detail} after {time.monotonic() - t0:.0f}s)"
             )
+        if fallback := ready.strip().partition("cpu-fallback: ")[2]:
+            log.warning("GPU unusable, decoding on CPU instead: %s "
+                        "(voiceio doctor shows the fix; model.device = \"cpu\" silences this)",
+                        fallback)
         elapsed = time.monotonic() - t0
         log.info("Model ready (%.1fs)", elapsed)
 

{python_voiceio-1.15.2 → python_voiceio-1.16.1}/voiceio/core/decoders/faster_whisper/worker.py

@@ -135,6 +135,39 @@ def decode(model: WhisperModel, audio: np.ndarray, kwargs: dict) -> list:
                                           kwargs.get("initial_prompt"))})
 
 
+def _load_and_warm(args: dict, device: str) -> WhisperModel:
+    model = load_model(
+        args["model"], device=device, compute_type=args["compute_type"],
+        cpu_threads=int(args.get("cpu_threads") or 0),
+    )
+    # Warmup: the first transcription is always slow. It also runs the first
+    # encode, where a CUDA build missing libcublas/libcudnn actually fails.
+    segs, _ = model.transcribe(np.zeros(16000, dtype=np.float32),
+                               language=args.get("language"), beam_size=1)
+    list(segs)
+    return model
+
+
+def load_ready(args: dict) -> tuple[WhisperModel, str]:
+    """The warmed-up model, and why it fell back to CPU ("" if it didn't).
+
+    device "auto" picks CUDA whenever a GPU is visible, even when the CUDA
+    libraries CTranslate2 needs are missing (a torch for another CUDA major
+    pulled in by the train extra): that failed every start and crash-looped
+    the service. On "auto" a GPU that can't run is a CPU decode instead;
+    an explicit "cuda" still fails loudly.
+    """
+    device = args["device"]
+    try:
+        return _load_and_warm(args, device), ""
+    except Exception as e:  # noqa: BLE001
+        if device != "auto":
+            raise
+        reason = " ".join(str(e).split())[:200] or type(e).__name__
+    print(f"voiceio: GPU unusable ({reason}); decoding on CPU", file=sys.stderr, flush=True)
+    return _load_and_warm(args, "cpu"), reason
+
+
 def main() -> None:
     # A hung decode is killed by the parent after a timeout; SIGUSR1 first
     # dumps every thread's stack to stderr (worker.log) so hangs are diagnosable.
@@ -142,15 +175,8 @@ def main() -> None:
     faulthandler.register(signal.SIGUSR1, all_threads=True)
 
     args = json.loads(sys.argv[1])
-    model = load_model(
-        args["model"], device=args["device"], compute_type=args["compute_type"],
-        cpu_threads=int(args.get("cpu_threads") or 0),
-    )
-
-    # Warmup: first transcription is always slow
-    segs, _ = model.transcribe(np.zeros(16000, dtype=np.float32), language=args.get("language"), beam_size=1)
-    list(segs)
-    print("READY", flush=True)
+    model, fallback = load_ready(args)
+    print(f"READY cpu-fallback: {fallback}" if fallback else "READY", flush=True)
 
     for line in sys.stdin:
         if line.strip() == "QUIT":

{python_voiceio-1.15.2 → python_voiceio-1.16.1}/voiceio/health.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 
 import logging
 from dataclasses import dataclass, field
+from pathlib import Path
 
 from voiceio import platform as plat
 from voiceio.hotkeys import chain as hotkey_chain
@@ -125,9 +126,66 @@ def check_health(p: plat.Platform | None = None) -> HealthReport:
                 "Grant it in System Settings → Privacy & Security → Accessibility."
             )
 
+    if gpu := _gpu_libs_warning():
+        report.warnings.append(gpu)
+    if kde := _kde_input_method_warning(report.platform):
+        report.warnings.append(kde)
+
     return report
 
 
+def _kde_input_method_warning(p: plat.Platform, kwinrc: Path | None = None) -> str:
+    """KWin on Wayland only hands text to the input method picked under
+    Virtual Keyboard; without IBus there, voiceio has no live preview."""
+    if not (p.desktop == "kde" and p.display_server == "wayland"):
+        return ""
+    import configparser
+    rc = configparser.ConfigParser(interpolation=None, strict=False)
+    try:
+        rc.read(kwinrc or Path.home() / ".config" / "kwinrc")
+    except configparser.Error:
+        return ""
+    # KWin writes it as "InputMethod[$e]" (a KConfig flag), so match the prefix.
+    section = rc["Wayland"] if rc.has_section("Wayland") else {}
+    if any(k.startswith("inputmethod") and "ibus" in v.lower() for k, v in section.items()):
+        return ""
+    return ("KDE isn't using IBus as its Wayland input method, so there's no live preview. "
+            "System Settings → Keyboard → Virtual Keyboard → IBus Wayland, then log out and in.")
+
+
+# What CTranslate2 4.x's CUDA build loads at the first encode.
+_CUDA_LIBS = ("libcublas.so.12", "libcudnn.so.9")
+
+
+def _gpu_libs_warning() -> str:
+    """Why Whisper can't use the GPU it sees, when that's a missing CUDA
+    library (a torch for another CUDA major, pulled in by the train extra,
+    is the usual way). The daemon then decodes on CPU instead."""
+    try:
+        from voiceio.config import load
+        cfg = load().model
+        from voiceio.core.decoders.catalog import is_whisper
+        if cfg.device not in ("auto", "cuda") or not is_whisper(cfg.name):
+            return ""
+        import ctranslate2
+        if ctranslate2.get_cuda_device_count() == 0:
+            return ""
+    except Exception:  # noqa: BLE001 — no faster-whisper, or no CUDA build
+        return ""
+    import ctypes
+    missing = []
+    for lib in _CUDA_LIBS:
+        try:
+            ctypes.CDLL(lib)
+        except OSError:
+            missing.append(lib)
+    if not missing:
+        return ""
+    return (f"A GPU is present but {', '.join(missing)} can't be loaded, so Whisper "
+            "decodes on CPU. Set model.device = \"cpu\" in config.toml to stay on CPU, "
+            "or install the CUDA 12 runtime (cuBLAS 12 and cuDNN 9) to use the GPU.")
+
+
 def _check_features() -> FeatureGroups:
     """Check which features are active based on config and files."""
     groups = FeatureGroups()

{python_voiceio-1.15.2 → python_voiceio-1.16.1}/voiceio/report.py

@@ -19,6 +19,7 @@ import urllib.parse
 import urllib.request
 import uuid
 from pathlib import Path
+from collections.abc import Sequence
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
@@ -27,7 +28,10 @@ if TYPE_CHECKING:
 BOARD_URL = "https://voiceio.dev/#feedback"
 POST_URL = "https://swarmmemo.com/w/voiceio/feedback"
 TIMEOUT_SECS = 8.0
-MAX_COMMENT = 300
+MAX_COMMENT = 1000
+# Insecure paths named in a report; more are counted.
+MAX_PERM_PATHS = 5
+WORKS = ("yes", "no", "not tried")
 MAX_DETAIL = 90
 
 # A terminal escape: CSI sequences (arrow keys) or ESC plus one key (Alt+key).
@@ -126,8 +130,9 @@ def build_report(
     health: HealthReport,
     *,
     missing_deps: list[str] | None = None,
-    perm_issues: int = 0,
+    perm_issues: Sequence[Path] = (),
     comment: str = "",
+    works: str = "",
     cfg=None,
 ) -> str:
     """The exact public text: short, plain, and scrubbed."""
@@ -168,7 +173,9 @@ def build_report(
     if not health.tray_ok:
         warned.append(f"tray: {_short(health.tray_reason)}" if health.tray_reason else "tray")
     if perm_issues:
-        warned.append(f"insecure permissions on {perm_issues} file(s)")
+        named = ", ".join(str(p) for p in perm_issues[:MAX_PERM_PATHS])
+        more = len(perm_issues) - MAX_PERM_PATHS
+        warned.append(f"insecure permissions on {named}" + (f" and {more} more" if more > 0 else ""))
     unavailable = [b.name for chosen, chain in ((hotkey, health.hotkey_backends),
                                                 (typer, health.typer_backends))
                    if chosen is not None for b in chain if not b.ok]
@@ -181,8 +188,8 @@ def build_report(
         f"backends: hotkey {hotkey.name if hotkey else 'none'} · "
         f"typer {typer.name if typer else 'none'} · audio {audio} "
         f"(vad {cfg.audio.vad_backend})"
-        + (" · voiceio not running" if health.ibus_checks is not None
-           and not health.ibus_checks.voiceio_running else ""),
+        + (" · voiceio was not running when this report was made"
+           if health.ibus_checks is not None and not health.ibus_checks.voiceio_running else ""),
         f"model: {_model_label(cfg.model.name)}",
     ]
     if unavailable:
@@ -191,7 +198,9 @@ def build_report(
     if warned:
         lines.append("warnings: " + "; ".join(warned))
     comment = "".join(c if c.isprintable() else " " for c in _ESCAPE.sub("", comment))
-    comment = " ".join(comment.split())[:MAX_COMMENT]
+    if works in WORKS:
+        lines.append(f"works: {works}")
+    comment = _clip(" ".join(comment.split()), MAX_COMMENT)
     if comment:
         lines.append(f"comment: {comment}")
     return scrub("\n".join(lines))
@@ -233,6 +242,28 @@ def _urlopen(url: str, *, timeout: float):
     return urllib.request.urlopen(req, timeout=timeout)
 
 
+def _clip(text: str, limit: int) -> str:
+    """At most `limit` characters, cut at a word with an ellipsis so a cut
+    comment doesn't read as the user's own last word."""
+    if len(text) <= limit:
+        return text
+    cut = text[:limit - 1]
+    word = cut.rsplit(" ", 1)[0]
+    return (word if len(word) >= len(cut) - 40 else cut) + "…"
+
+
+def ask_details() -> tuple[str, str]:
+    """Two questions for a report filed from a terminal: what happened, and
+    whether dictation types into apps. Enter skips either."""
+    comment = _ask("\n  What happened? One or two sentences for the public board "
+                   "(Enter to skip): ").strip()
+    answer = _ask("  Does dictation type text into your apps? [y/n/not tried, Enter to skip]: ")
+    answer = answer.strip().lower()
+    works = {"y": "yes", "yes": "yes", "n": "no", "no": "no",
+             "not tried": "not tried", "t": "not tried", "nt": "not tried"}.get(answer, "")
+    return comment, works
+
+
 def _interactive() -> bool:
     return sys.stdin.isatty() and sys.stdout.isatty()
 
@@ -279,7 +310,7 @@ def gather(comment: str = "") -> tuple[HealthReport, str]:
     return health, build_report(
         health,
         missing_deps=plat.check_system_deps(),
-        perm_issues=len(config.check_permissions()),
+        perm_issues=[p for p, _, _ in config.check_permissions()],
         comment=comment,
     )