vocalize-cli 0.10.0__tar.gz → 0.10.2__tar.gz

{vocalize_cli-0.10.0 → vocalize_cli-0.10.2}/.gitignore

@@ -11,5 +11,6 @@ dist/
 venv/
 *.mp3
 *.wav
+!vocalize/assets/cues/*.wav
 .claude/
 uv.lock

{vocalize_cli-0.10.0 → vocalize_cli-0.10.2}/CHANGELOG.md

@@ -3,6 +3,68 @@
 All notable changes to this project are documented here. Format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
+## 0.10.2 - 2026-09-02
+
+### Added
+
+- **`[stt] cues`** picks what a dictation's feedback sounds — say instead
+  of, or alongside, the Tink/Pop/Glass system sounds. `"sounds"` (default)
+  is unchanged; `"words"` speaks "Start.", "Stopped.", "Ready." in their
+  place; `"both"` speaks the word and then plays the sound. The word files
+  ship in `vocalize/assets/cues/`, generated with the local Kokoro voice.
+  A spoken "Start." plays *before* the recorder launches — played once the
+  microphone was open it would be recorded and transcribed along with the
+  dictation. In `"both"` mode the Tink still plays *after* the microphone
+  opens, so the two cues keep distinct meanings: the word is "get ready",
+  the sound is "talk now". The plain Tink is unaffected.
+
+### Known issue
+
+- In `"words"` mode there is no cue for the moment the microphone actually
+  opens, which is a second or so after "Start." finishes (LaunchServices
+  start-up plus the input device switching on). People start talking too
+  soon and lose their first word. The fix — open and warm the microphone
+  first, play the cue, and only then capture — is tracked in
+  [#2](https://github.com/matthager12-collab/vocalize/issues/2). Until
+  then: in `"words"` mode, wait a beat after "Start."; in `"both"` mode,
+  talk after the Tink.
+
+## 0.10.1 - 2026-09-02
+
+Three fixes found in the first owner-present run of 0.10.0's dictation.
+Together they meant no hotkey dictation could succeed on 0.10.0; upgrade.
+
+### Fixed
+
+- **No dictation could ever start on a fresh install.** The recorder was
+  signed with the hardened runtime but without the
+  `com.apple.security.device.audio-input` entitlement, so macOS refused the
+  microphone on the spot — no permission dialog, status stuck at
+  `notDetermined` — and every first press ended in "The recorder did not
+  start". The bundle is now signed with
+  `vocalize/recorder/Recorder.entitlements`, and the entitlements are part
+  of the recorder's fingerprint, so `vocalize local install --stt` rebuilds
+  the bundle once (and, as with any rebuild, macOS asks for the microphone
+  again — it never actually asked before).
+- **Every hotkey dictation ended in "Dictation failed" on a machine whose
+  `uv` came from Homebrew.** A Services environment has a bare PATH, and
+  `uv_path()` looked only there and in `~/.local/bin`; the same dictation
+  worked from a terminal. `/opt/homebrew/bin/uv` and `/usr/local/bin/uv`
+  are now tried too (this also covers Kokoro from a Quick Action).
+- **Holding the dictation hotkey down turned into a cancel-and-restart
+  loop.** macOS re-fires a Service shortcut at the key-repeat rate, and
+  every repeat landed as a second press. Presses within half a second of
+  the previous one are now ignored as the same press; a deliberate cancel
+  is "press, a beat, press" inside the two-second window, as before.
+- `hooks/claude_stop_hook.py --latest`, run from inside a Claude Code turn
+  (which is how `/speak` runs it), spoke the agent's own status line —
+  "Checking settings." — instead of the response the user asked to hear.
+  It now skips the turn in progress, back past the `/speak` message
+  itself, and speaks the response before it. From a plain terminal, where
+  no turn is in progress, `--latest` still speaks the newest response; the
+  hook tells the two apart by the `CLAUDECODE` variable Claude Code sets
+  in its shell. The Stop-hook path is unchanged.
+
 ## 0.10.0 - 2026-09-02
 
 ### Added

{vocalize_cli-0.10.0 → vocalize_cli-0.10.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: vocalize-cli
-Version: 0.10.0
+Version: 0.10.2
 Summary: A CLI that turns text, markdown, or piped stdin into speech via the ElevenLabs API, with markdown-table-aware preprocessing.
 Project-URL: Homepage, https://github.com/matthager12-collab/vocalize
 Project-URL: Repository, https://github.com/matthager12-collab/vocalize
@@ -478,12 +478,15 @@ terminal, if you'd rather trigger it that way.
   transcript is on your clipboard; nothing is typed for you automatically.
 - **Nothing heard** (silence, or a microphone that isn't actually picking
   anything up) ends the dictation quietly — no clipboard write.
-- **Cancel** with a second press *within two seconds* of the first, or at
+- **Cancel** with a second press *within two seconds* of the first (but
+  not within half a second — that's a held key, and it's ignored), or at
   any point with `vocalize listen --cancel` — the audio is discarded, never
   transcribed.
 - **A third press while transcribing is refused**: a Pop, and "Still
   transcribing the last dictation." Wait for the clipboard notification, or
   `--cancel`, before dictating again.
+- Can't tell Tink from Pop from Glass yet? Set `[stt] cues = "words"` and
+  vocalize says "Start.", "Stopped.", "Ready." instead.
 
 ### `vocalize listen`
 
@@ -518,6 +521,7 @@ input_device = ""      # "" = system default; else an exact name from --list-dev
 cleanup = false        # send the transcript (never audio) to Claude first
 max_seconds = 120      # 1-600; the recorder self-stops here, dictate backstops it
 sounds = true          # the Tink/Pop/Glass feedback sounds
+cues = "sounds"        # "sounds" | "words" | "both" — speak "Start."/"Stopped."/"Ready." instead
 ```
 
 | Key | Allowed values | Default |
@@ -529,6 +533,7 @@ sounds = true          # the Tink/Pop/Glass feedback sounds
 | `paste` | reserved — not implemented in 0.10.0 | `false` |
 | `max_seconds` | integer, 1–600 | `120` |
 | `sounds` | `true` / `false` | `true` |
+| `cues` | `sounds`, `words`, `both` | `sounds` |
 
 An unknown key warns on stderr; a bad value is a `ConfigError` naming it —
 every one of these becomes a subprocess argument eventually, so nothing

{vocalize_cli-0.10.0 → vocalize_cli-0.10.2}/README.md

@@ -442,12 +442,15 @@ terminal, if you'd rather trigger it that way.
   transcript is on your clipboard; nothing is typed for you automatically.
 - **Nothing heard** (silence, or a microphone that isn't actually picking
   anything up) ends the dictation quietly — no clipboard write.
-- **Cancel** with a second press *within two seconds* of the first, or at
+- **Cancel** with a second press *within two seconds* of the first (but
+  not within half a second — that's a held key, and it's ignored), or at
   any point with `vocalize listen --cancel` — the audio is discarded, never
   transcribed.
 - **A third press while transcribing is refused**: a Pop, and "Still
   transcribing the last dictation." Wait for the clipboard notification, or
   `--cancel`, before dictating again.
+- Can't tell Tink from Pop from Glass yet? Set `[stt] cues = "words"` and
+  vocalize says "Start.", "Stopped.", "Ready." instead.
 
 ### `vocalize listen`
 
@@ -482,6 +485,7 @@ input_device = ""      # "" = system default; else an exact name from --list-dev
 cleanup = false        # send the transcript (never audio) to Claude first
 max_seconds = 120      # 1-600; the recorder self-stops here, dictate backstops it
 sounds = true          # the Tink/Pop/Glass feedback sounds
+cues = "sounds"        # "sounds" | "words" | "both" — speak "Start."/"Stopped."/"Ready." instead
 ```
 
 | Key | Allowed values | Default |
@@ -493,6 +497,7 @@ sounds = true          # the Tink/Pop/Glass feedback sounds
 | `paste` | reserved — not implemented in 0.10.0 | `false` |
 | `max_seconds` | integer, 1–600 | `120` |
 | `sounds` | `true` / `false` | `true` |
+| `cues` | `sounds`, `words`, `both` | `sounds` |
 
 An unknown key warns on stderr; a bad value is a `ConfigError` naming it —
 every one of these becomes a subprocess argument eventually, so nothing

{vocalize_cli-0.10.0 → vocalize_cli-0.10.2}/docs/dictation.md

@@ -132,7 +132,10 @@ touching System Settings at all.
 
 **A second press within two seconds of the first is a cancel**, not a
 stop — treated as "I changed my mind" rather than the end of a very short
-sentence. So is `vocalize listen --cancel`, from a terminal, at any point
+sentence. (Presses closer than half a second apart are the key being
+*held* — macOS repeats a Service shortcut at the key-repeat rate — and are
+ignored, so a cancel is "press, a beat, press".) So is
+`vocalize listen --cancel`, from a terminal, at any point
 — including while a take is being transcribed. (The transcription that was
 already running keeps its own copy of the recording and finishes normally;
 `--cancel` only releases the hotkey so your next press starts a fresh
@@ -144,6 +147,16 @@ never runs two transcriptions over the same recording, and it never
 silently drops one either. Wait for the clipboard notification, or use
 `--cancel`.
 
+New to the sounds and can't tell Tink from Pop from Glass? Set
+`[stt] cues = "words"` and vocalize says "Start.", "Stopped." and "Ready."
+instead, or `"both"` to hear the word and then its sound — see the `[stt]`
+table below. Timing matters: "Start." is spoken *before* the microphone
+opens (so it is never in your recording), and the microphone is open
+about a second later — the Tink marks that moment. So in `"both"` mode
+talk after the Tink; in `"words"` mode give it a beat after "Start.".
+Closing that gap is
+[#2](https://github.com/matthager12-collab/vocalize/issues/2).
+
 ## `vocalize listen`
 
 The terminal-facing primitive behind the hotkey:
@@ -213,6 +226,7 @@ cleanup = false
 paste = false
 max_seconds = 120
 sounds = true
+cues = "sounds"  # "sounds" | "words" | "both"
 ```
 
 | Key | Type / allowlist | Default | Notes |
@@ -223,7 +237,8 @@ sounds = true
 | `cleanup` | `true` / `false` | `false` | see `--cleanup` above |
 | `paste` | reserved | `false` | not implemented in 0.10.0 — setting it does nothing |
 | `max_seconds` | integer, 1–600 | `120` | the recorder self-stops here; `dictate` backstops it a few seconds later in case the recorder doesn't |
-| `sounds` | `true` / `false` | `true` | the Tink/Pop/Glass feedback; `false` silences all three |
+| `sounds` | `true` / `false` | `true` | the Tink/Pop/Glass feedback; `false` silences all three (words included) |
+| `cues` | `sounds`, `words`, `both` | `sounds` | `"words"` speaks "Start.", "Stopped.", "Ready." instead of the system sounds; `"both"` speaks the word and then plays the sound — for the start cue, the word before the microphone opens and the Tink once it has. Has no effect while `sounds = false`. |
 
 Every value here eventually becomes a subprocess argument — the recorder's
 `--device`, or the whisper worker's `--model`/`--language` — so each one is
@@ -240,6 +255,7 @@ stt.model=small.en
 stt.language=en
 stt.cleanup=false
 stt.max_seconds=120
+stt.cues=sounds
 ```
 
 ### The input-device gotcha

{vocalize_cli-0.10.0 → vocalize_cli-0.10.2}/docs/plans/2026-09-next-features/run-6-release-0-10-0/report.md

@@ -11,6 +11,7 @@ Branch `next-features`, shared checkout. Source: [project-plan.md](./project-pla
   - `status` (no mic): [run-1-status/report.md](../run-1-status/report.md) (the module and its exit-code contract) plus [run-4-dictation/report.md](../run-4-dictation/report.md) T-45 (the four STT readiness rows), further hardened this run (mic-verdict age, locked probe registry — see review-0.10.0.md).
   - Resume drill (no mic): [run-5-resume/report.md](../run-5-resume/report.md) T-46/T-47, with this run's review closing the gaps it left open (DEC-013's queued-read case, DEC-014f's voice/speed/chunking carry-over).
   - Note: rebuilding the recorder for the Swift permission-dialog fix (`94e5a46`) reset the microphone grant on the reference Mac to `notDetermined`, so Manual check 1 starts from a genuinely fresh state — not a regression, the state the fix exists for.
+  - **Owner-present run, 2026-09-02 evening (after 0.10.0 published):** Manual check 1 (mic grant) and 2 (hotkey path, real voice, transcript on the clipboard) done — but only after three defects were fixed and released as 0.10.1: the recorder was signed with the hardened runtime and no `audio-input` entitlement (no prompt ever appeared); `uv_path()` could not find Homebrew's uv from a Service's bare PATH (every stop ended in "Dictation failed"); and a held hotkey re-fired as serial cancel/restart presses (now debounced). Manual 3 is partly covered (held-key refusal); 4, 4b, 4c and 5 remain.
 - **T-53: pending** — merge and publish. Not started. This run does not merge to main or publish; per project-plan.md that happens on the owner's word, after T-52. The orchestrator handles this after reading this report.
 
 ## Security-gate summary (every run's verdict)

vocalize_cli-0.10.2/docs/roadmap.md

@@ -0,0 +1,25 @@
+# Roadmap
+
+Future work, with the research behind each item. Status legend: **planned** = analysed, decisions pending, nothing built; **spiked** = feasibility measured; **building**; **shipped**.
+
+| Item | Status | Tracking | Research |
+|---|---|---|---|
+| Hotkey-triggered local dictation (voice → text via a local Whisper model, Quick Action toggle, clipboard output, optional cleanup) | **shipped** in 0.10.0, usable from 0.10.1 | [#1](https://github.com/matthager12-collab/vocalize/issues/1) · [plan](plans/2026-09-next-features/plan.md) | [analysis](next-features-analysis.md) · [full design](research/2026-09-01-dictation-design.md) · [voicebox findings](research/2026-09-01-voicebox-findings.md) |
+| `vocalize status` one-screen readiness check | **shipped** in 0.10.0 | [#1](https://github.com/matthager12-collab/vocalize/issues/1) | [analysis](next-features-analysis.md) |
+| Spoken cues for dictation (`[stt] cues = "words"`: "start" / "stopped" / "ready" instead of, or as well as, the sounds) | **shipped** in 0.10.2 | — | owner request, 2026-09-02 |
+| Cue timing: the "talk now" cue must follow the *open* microphone and never be recorded (recorder warms the input, reports ready, waits for a `go` marker; `dictate` plays the cue, then touches `go`) | planned | [#2](https://github.com/matthager12-collab/vocalize/issues/2) | first live use of 0.10.2: people talk after "Start." and lose the first word |
+| Config portal (`vocalize portal`, stdlib local web page on top of the same readiness rows) | planned — runs 7–10 of the [plan](plans/2026-09-next-features/plan.md) | [#1](https://github.com/matthager12-collab/vocalize/issues/1) | [analysis](next-features-analysis.md) · [full design](research/2026-09-01-config-portal-design.md) |
+
+## Decisions (2026-09-01, closed 2026-09-02)
+
+1. The dictation spike ran ([results](plans/2026-09-next-features/spike-2026-09-01.md)); Whisper `small.en` is the default.
+2. `vocalize status` first (0.10.0); the portal follows as 0.11.0.
+3. Hotkey chord ⌃⌥⌘D, set by the user in System Settings.
+
+## Deferred on purpose
+
+Hold-to-talk (needs an event tap + Input Monitoring, ~6 h), auto-paste (Accessibility, ~2 h, belongs in the recorder bundle), Apple STT mode (~1.5 h), menu-bar agent (~12 h), local-LLM cleanup, resident/pre-warmed STT worker (only if the spike shows >2.5 s overhead), a native SwiftUI/Tauri app.
+
+## Sequencing suggestion
+
+Dictation first (the spike decides the engine, then ~20 h), portal or `status` second.

{vocalize_cli-0.10.0 → vocalize_cli-0.10.2}/hooks/claude_stop_hook.py

@@ -7,7 +7,10 @@
 2. On demand, with `--latest`. Nothing is read from stdin; the script finds
    the most recently written transcript under ~/.claude/projects and speaks
    that response. Run it when you want speech instead of installing the
-   hook and getting it after every turn.
+   hook and getting it after every turn. Run from inside a Claude Code turn
+   (the /speak command does this; Claude Code sets CLAUDECODE=1 in its
+   shell) it skips that turn — the newest text there is the agent's own
+   status line — and speaks the response before it.
 
 Add `--print-length` to either mode to print the response's character
 count instead of speaking — for wrappers deciding whether to ask about
@@ -59,7 +62,27 @@ def _speech_timeout(text: str) -> int:
     return min(TIMEOUT_CEILING_SECONDS, TIMEOUT_BASE_SECONDS + len(text) // CHARS_PER_SECOND)
 
 
-def _extract_last_assistant_text(transcript_path: str) -> str:
+def _is_human_message(entry: dict) -> bool:
+    """A user entry the person typed, not one Claude Code wrote.
+
+    Claude Code logs tool results and its own injected text — a skill's
+    body, say — as user entries too; the latter carry ``isMeta``.
+    """
+    if entry.get("type") != "user" or entry.get("isMeta"):
+        return False
+    content = (entry.get("message") or {}).get("content") or []
+    if isinstance(content, str):
+        return True
+    return any(isinstance(b, dict) and b.get("type") != "tool_result" for b in content)
+
+
+def _extract_last_assistant_text(transcript_path: str, skip_current_turn: bool = False) -> str:
+    """Newest assistant text in the transcript.
+
+    With skip_current_turn, everything after the newest human message is
+    the turn still in progress (the one running this script); skip it and
+    return the response before that message instead.
+    """
     last_text_parts: list[str] = []
     try:
         with open(transcript_path, "r", encoding="utf-8") as f:
@@ -76,6 +99,11 @@ def _extract_last_assistant_text(transcript_path: str) -> str:
         except json.JSONDecodeError:
             continue
 
+        if skip_current_turn:
+            if _is_human_message(entry):
+                skip_current_turn = False  # past the /speak message; older is fair game
+            continue
+
         if entry.get("type") != "assistant":
             continue
 
@@ -117,17 +145,24 @@ def main() -> int:
     if "--latest" in sys.argv[1:]:
         # On-demand mode: no hook payload on stdin, so don't read it at all.
         transcript_path = _find_latest_transcript()
+        # Run from inside a Claude Code turn (the /speak command does this,
+        # and Claude Code sets CLAUDECODE=1 in its shell), the newest
+        # assistant text is that turn's own status line — "Checking
+        # settings." — not the response the user asked to hear. From a plain
+        # terminal there is no turn in progress and the newest text is right.
+        skip_current_turn = bool(os.environ.get("CLAUDECODE"))
     else:
         try:
             payload = json.load(sys.stdin)
         except json.JSONDecodeError:
             payload = {}
         transcript_path = payload.get("transcript_path")
+        skip_current_turn = False  # at Stop the turn is over: newest text is the target
 
     if not transcript_path:
         return 0  # nothing to do — don't block Claude Code on a hook error
 
-    text = _extract_last_assistant_text(transcript_path)
+    text = _extract_last_assistant_text(transcript_path, skip_current_turn)
     if not text.strip():
         if "--print-length" in sys.argv[1:]:
             print(0)

{vocalize_cli-0.10.0 → vocalize_cli-0.10.2}/tests/test_claude_stop_hook.py

@@ -14,6 +14,10 @@ def _assistant(content) -> str:
     return json.dumps({"type": "assistant", "message": {"content": content}})
 
 
+def _user(content, **extra) -> str:
+    return json.dumps({"type": "user", "message": {"content": content}, **extra})
+
+
 def _text(text: str) -> dict:
     return {"type": "text", "text": text}
 
@@ -28,6 +32,9 @@ def _patch_main(monkeypatch, payload, which="/usr/local/bin/vocalize", run=None,
     """Wire up stdin, PATH lookup and subprocess so main() can't shell out."""
     monkeypatch.delenv("VOCALIZE_MAX_CHARS", raising=False)
     monkeypatch.delenv("VOCALIZE_BIN", raising=False)
+    # The suite itself often runs inside a Claude Code turn, where this is
+    # set; a --latest test must not change meaning depending on who ran it.
+    monkeypatch.delenv("CLAUDECODE", raising=False)
     monkeypatch.setattr(hook.sys, "argv", ["claude_stop_hook.py"])
     monkeypatch.setattr(
         hook.sys, "stdin", io.StringIO(json.dumps(payload)) if stdin is None else stdin
@@ -102,6 +109,31 @@ def test_falls_back_past_tool_use_only_entry(tmp_path):
     assert hook._extract_last_assistant_text(path) == "the spoken answer"
 
 
+def test_skip_current_turn_returns_the_response_before_the_newest_human_message(tmp_path):
+    # /speak runs the hook mid-turn. By then the agent has written a status
+    # line and Claude Code has logged the Bash call that runs the hook (and
+    # its result). The response the user wants is the one BEFORE /speak.
+    # Only the typed /speak line counts as the person speaking: tool results
+    # and Claude Code's own injected text (isMeta) are user entries too.
+    path = _write_transcript(
+        tmp_path,
+        [
+            _assistant([_text("the long response the user asked to hear")]),
+            _user("<command-name>/speak</command-name>"),
+            _user([_text("Base directory for this skill: ...")], isMeta=True),
+            _assistant([_text("Checking settings.")]),
+            _assistant([{"type": "tool_use", "name": "Bash", "input": {}}]),
+            _user([{"type": "tool_result", "tool_use_id": "t1", "content": "ok"}]),
+        ],
+    )
+
+    assert hook._extract_last_assistant_text(path, skip_current_turn=True) == (
+        "the long response the user asked to hear"
+    )
+    # The Stop-hook path still wants the newest text: at Stop, the turn is over.
+    assert hook._extract_last_assistant_text(path) == "Checking settings."
+
+
 def test_ignores_malformed_json_lines(tmp_path):
     # The garbage line must sit AFTER the newest assistant entry. The scan
     # walks reversed(lines) and breaks on the first text it finds, so a
@@ -326,6 +358,35 @@ def test_latest_mode_speaks_newest_transcript_without_reading_stdin(monkeypatch,
     assert calls[0][-1] == "newest session"
 
 
+def test_latest_mode_skips_the_current_turn_only_inside_claude_code(monkeypatch, tmp_path):
+    transcript = tmp_path / "session.jsonl"
+    transcript.write_text(
+        "\n".join(
+            [
+                _assistant([_text("the long response")]),
+                _user("/speak"),
+                _assistant([_text("Checking settings.")]),
+            ]
+        )
+        + "\n",
+        encoding="utf-8",
+    )
+    calls = _patch_main(monkeypatch, {})
+    monkeypatch.setattr(hook.sys, "argv", ["claude_stop_hook.py", "--latest"])
+    monkeypatch.setattr(hook, "_find_latest_transcript", lambda: str(transcript))
+
+    # From a plain terminal there is no turn in progress: newest text wins,
+    # exactly as the README's on-demand mode promises.
+    assert hook.main() == 0
+    assert calls[-1][-1] == "Checking settings."
+
+    # Inside a Claude Code turn, that newest text is the agent's own status
+    # line; the user wants the response before their /speak.
+    monkeypatch.setenv("CLAUDECODE", "1")
+    assert hook.main() == 0
+    assert calls[-1][-1] == "the long response"
+
+
 def test_subprocess_failure_is_logged_not_raised(monkeypatch, tmp_path, capsys):
     def boom(argv):
         raise RuntimeError("no audio device")

{vocalize_cli-0.10.0 → vocalize_cli-0.10.2}/tests/test_cli.py

@@ -624,8 +624,10 @@ def test_settings_prints_the_stt_lines(monkeypatch, tmp_path):
     _isolate_overflow_env(monkeypatch, tmp_path)
     cfg = tmp_path / "vocalize" / "config.toml"
     cfg.parent.mkdir(parents=True, exist_ok=True)
-    cfg.write_text('[stt]\nmodel = "base.en"\ncleanup = true\nmax_seconds = 30\n',
-                   encoding="utf-8")
+    cfg.write_text(
+        '[stt]\nmodel = "base.en"\ncleanup = true\nmax_seconds = 30\ncues = "sounds"\n',
+        encoding="utf-8",
+    )
 
     result = CliRunner().invoke(main, ["settings"])
 
@@ -634,6 +636,7 @@ def test_settings_prints_the_stt_lines(monkeypatch, tmp_path):
     assert "stt.language=en" in result.output
     assert "stt.cleanup=true" in result.output
     assert "stt.max_seconds=30" in result.output
+    assert "stt.cues=sounds" in result.output
 
 
 def test_settings_prints_defaults_when_nothing_is_configured(monkeypatch, tmp_path):

{vocalize_cli-0.10.0 → vocalize_cli-0.10.2}/tests/test_config.py

@@ -697,6 +697,30 @@ def test_a_non_boolean_stt_flag_is_refused(monkeypatch, tmp_path, key):
     assert f"stt.{key}" in str(excinfo.value)
 
 
+@pytest.mark.parametrize("value", ['"chime"', "1"])
+def test_an_invalid_stt_cues_value_is_refused(monkeypatch, tmp_path, value):
+    with pytest.raises(ConfigError) as excinfo:
+        _load_stt(monkeypatch, tmp_path, f"[stt]\ncues = {value}\n")
+
+    message = str(excinfo.value)
+    assert "stt.cues" in message
+    assert "sounds" in message and "words" in message and "both" in message
+
+
+@pytest.mark.parametrize("value", ["sounds", "words", "both"])
+def test_each_stt_cues_mode_is_accepted(monkeypatch, tmp_path, value):
+    from vocalize.config import resolve_stt
+
+    data = _load_stt(monkeypatch, tmp_path, f'[stt]\ncues = "{value}"\n')
+    assert resolve_stt(data)["cues"] == value
+
+
+def test_stt_cues_defaults_to_sounds(monkeypatch, tmp_path):
+    from vocalize.config import resolve_stt
+
+    assert resolve_stt(_load_stt(monkeypatch, tmp_path, ""))["cues"] == "sounds"
+
+
 def test_an_stt_value_that_is_not_a_table_is_refused(monkeypatch, tmp_path):
     with pytest.raises(ConfigError) as excinfo:
         _load_stt(monkeypatch, tmp_path, 'stt = "small.en"\n')

vocalize_cli-0.10.2/tests/test_cue_assets.py

@@ -0,0 +1,28 @@
+"""The shipped `[stt] cues` word files: present, small, and well-formed.
+
+Not a test of speech quality — just the shape that `dictate._play` and the
+packaged wheel both depend on: a real mono 16-bit WAV, short and light
+enough to ship and to speak without lagging behind the sound it replaces.
+"""
+
+import wave
+from pathlib import Path
+
+import pytest
+
+from vocalize.dictate import _CUE_WORDS
+
+MAX_SECONDS = 1.5
+MAX_BYTES = 80_000
+
+
+@pytest.mark.parametrize("path", list(_CUE_WORDS.values()), ids=lambda p: p.name)
+def test_a_cue_word_file_is_a_small_mono_16_bit_wav(path: Path):
+    assert path.is_file(), f"missing cue asset: {path}"
+    assert path.stat().st_size <= MAX_BYTES
+
+    with wave.open(str(path), "rb") as reader:
+        assert reader.getnchannels() == 1
+        assert reader.getsampwidth() == 2
+        duration = reader.getnframes() / reader.getframerate()
+    assert duration <= MAX_SECONDS