stackvox 0.9.0__tar.gz → 0.11.0__tar.gz

{stackvox-0.9.0/stackvox.egg-info → stackvox-0.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stackvox
-Version: 0.9.0
+Version: 0.11.0
 Summary: Offline TTS library using Kokoro-82M
 Author-email: "StackOne Technologies Ltd." <support@stackone.com>
 License-Expression: Apache-2.0
@@ -103,7 +103,11 @@ stackvox speak --normalize --file post.md       # normalize, then synthesize
 stackvox say   --normalize "**Shipped** 1,198.9 MPG"   # normalize, then send to daemon
 ```
 
-`--normalize` is off by default on `speak`/`say`, so notification phrases synthesize exactly as before. The tuning flags mirror the library defaults (all on except emoji-strip): `--no-markdown`, `--no-expand-units`, `--no-expand-numbers`, `--no-pauses`, `--tables {drop,csv}`, `--strip-emoji`, `--no-terminal-stops`, `--locale`, and a `--pronunciations FILE` (a JSON `{"written": "spoken"}` map, applied whole-word and case-insensitively).
+`--normalize` is off by default on `speak`/`say`, so notification phrases synthesize exactly as before. The tuning flags mirror the library defaults (all on except emoji-strip): `--no-markdown`, `--no-dev-terms`, `--no-expand-units`, `--no-expand-numbers`, `--no-pauses`, `--tables {drop,csv}`, `--code-blocks {drop,placeholder}`, `--strip-emoji`, `--no-terminal-stops`, `--locale`, and a `--pronunciations FILE` (a JSON `{"written": "spoken"}` map, applied whole-word and case-insensitively).
+
+**Dev-output handling** (on by default; `--no-dev-terms` to disable) covers two things espeak reads badly: acronyms it says as words (`CLI` → "C L I", `AWS`, `URI`, `IAM`, …) and file-line references, which it voices literally as "dot py colon". A `file.ext:line` ref is re-spoken lead-with-the-line: `engine.py:42` → "line 42 of engine py", `cli.py:100-118` → "lines 100 to 118 of cli py", `foo.ts:666:10` → "line 666, column 10 of foo ts". Times, ratios, and versions (`12:30`, `3:1`, `1.2.3`) are left alone.
+
+Fenced code blocks are dropped by default. `--code-blocks placeholder` instead speaks a short stand-in so a skipped block doesn't sound disjointed (ChatGPT-style) — set the wording with `--code-placeholder` (e.g. `--code-blocks placeholder --code-placeholder "you can see the code in the chat history"`); consecutive blocks collapse to one.
 
 Bash completion:
 

{stackvox-0.9.0 → stackvox-0.11.0}/README.md

@@ -69,7 +69,11 @@ stackvox speak --normalize --file post.md       # normalize, then synthesize
 stackvox say   --normalize "**Shipped** 1,198.9 MPG"   # normalize, then send to daemon
 ```
 
-`--normalize` is off by default on `speak`/`say`, so notification phrases synthesize exactly as before. The tuning flags mirror the library defaults (all on except emoji-strip): `--no-markdown`, `--no-expand-units`, `--no-expand-numbers`, `--no-pauses`, `--tables {drop,csv}`, `--strip-emoji`, `--no-terminal-stops`, `--locale`, and a `--pronunciations FILE` (a JSON `{"written": "spoken"}` map, applied whole-word and case-insensitively).
+`--normalize` is off by default on `speak`/`say`, so notification phrases synthesize exactly as before. The tuning flags mirror the library defaults (all on except emoji-strip): `--no-markdown`, `--no-dev-terms`, `--no-expand-units`, `--no-expand-numbers`, `--no-pauses`, `--tables {drop,csv}`, `--code-blocks {drop,placeholder}`, `--strip-emoji`, `--no-terminal-stops`, `--locale`, and a `--pronunciations FILE` (a JSON `{"written": "spoken"}` map, applied whole-word and case-insensitively).
+
+**Dev-output handling** (on by default; `--no-dev-terms` to disable) covers two things espeak reads badly: acronyms it says as words (`CLI` → "C L I", `AWS`, `URI`, `IAM`, …) and file-line references, which it voices literally as "dot py colon". A `file.ext:line` ref is re-spoken lead-with-the-line: `engine.py:42` → "line 42 of engine py", `cli.py:100-118` → "lines 100 to 118 of cli py", `foo.ts:666:10` → "line 666, column 10 of foo ts". Times, ratios, and versions (`12:30`, `3:1`, `1.2.3`) are left alone.
+
+Fenced code blocks are dropped by default. `--code-blocks placeholder` instead speaks a short stand-in so a skipped block doesn't sound disjointed (ChatGPT-style) — set the wording with `--code-placeholder` (e.g. `--code-blocks placeholder --code-placeholder "you can see the code in the chat history"`); consecutive blocks collapse to one.
 
 Bash completion:
 

{stackvox-0.9.0 → stackvox-0.11.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "stackvox"
-version = "0.9.0"
+version = "0.11.0"
 description = "Offline TTS library using Kokoro-82M"
 readme = "README.md"
 requires-python = ">=3.10"

{stackvox-0.9.0 → stackvox-0.11.0}/stackvox/cli.py

@@ -26,6 +26,7 @@ def _configure_logging() -> None:
 SUBCOMMANDS = {
     "serve",
     "stop",
+    "cancel",
     "status",
     "say",
     "speak",
@@ -51,7 +52,7 @@ _stackvox_completion() {
     subcommand="${COMP_WORDS[1]:-}"
 
     if [[ ${COMP_CWORD} -eq 1 ]]; then
-        COMPREPLY=( $(compgen -W "speak say normalize serve stop status voices welcome paths config completion install-helper" -- "$cur") )
+        COMPREPLY=( $(compgen -W "speak say normalize serve stop cancel status voices welcome paths config completion install-helper" -- "$cur") )
         return 0
     fi
 
@@ -76,13 +77,17 @@ _stackvox_completion() {
             COMPREPLY=( $(compgen -W "drop csv" -- "$cur") )
             return 0
             ;;
+        --code-blocks)
+            COMPREPLY=( $(compgen -W "drop placeholder" -- "$cur") )
+            return 0
+            ;;
         --locale)
             COMPREPLY=( $(compgen -W "en-GB" -- "$cur") )
             return 0
             ;;
     esac
 
-    local norm_flags="--no-markdown --pronunciations --no-expand-units --no-expand-numbers --no-pauses --tables --strip-emoji --no-terminal-stops --locale"
+    local norm_flags="--no-markdown --no-dev-terms --pronunciations --no-expand-units --no-expand-numbers --no-pauses --tables --code-blocks --code-placeholder --strip-emoji --no-terminal-stops --locale"
 
     case "$subcommand" in
         speak)
@@ -155,6 +160,7 @@ def _build_parser(defaults: config.Defaults | None = None) -> argparse.ArgumentP
     _add_voice_args(p_serve, defaults)
 
     sub.add_parser("stop", help="Stop the running daemon")
+    sub.add_parser("cancel", help="Stop the current utterance without shutting down the daemon")
     sub.add_parser("status", help="Print daemon status")
     sub.add_parser("voices", help="List available voices")
     sub.add_parser("welcome", help="Play a multilingual welcome message")
@@ -238,6 +244,19 @@ def _add_normalize_args(parser: argparse.ArgumentParser, *, with_switch: bool) -
         default="drop",
         help="How Markdown tables are voiced (default: drop)",
     )
+    parser.add_argument(
+        "--code-blocks",
+        dest="code_blocks",
+        choices=["drop", "placeholder"],
+        default="drop",
+        help="How fenced code blocks are voiced (default: drop)",
+    )
+    parser.add_argument(
+        "--code-placeholder",
+        dest="code_placeholder",
+        default="Code block.",
+        help='Spoken stand-in for a code block when --code-blocks placeholder (default: "Code block.")',
+    )
     parser.add_argument(
         "--strip-emoji", dest="strip_emoji", action="store_true", help="Remove emoji before speaking"
     )
@@ -279,6 +298,8 @@ def _normalize_kwargs(args: argparse.Namespace) -> dict:
         "expand_numbers": args.expand_numbers,
         "pauses": args.pauses,
         "tables": args.tables,
+        "code_blocks": args.code_blocks,
+        "code_placeholder": args.code_placeholder,
         "strip_emoji": args.strip_emoji,
         "terminal_stops": args.terminal_stops,
         "locale": args.locale,
@@ -388,6 +409,15 @@ def _cmd_stop(_: argparse.Namespace) -> int:
     return 0 if ok else 1
 
 
+def _cmd_cancel(_: argparse.Namespace) -> int:
+    # Interrupt the current utterance but leave the daemon running (no model
+    # reload). Nothing playing / no daemon is not an error.
+    if not daemon.is_running():
+        return 0
+    ok, _resp = daemon.cancel()
+    return 0 if ok else 1
+
+
 def _cmd_status(_: argparse.Namespace) -> int:
     installed = updates._current_version()
     if daemon.is_running():
@@ -530,6 +560,7 @@ def main() -> int:
         "normalize": _cmd_normalize,
         "serve": _cmd_serve,
         "stop": _cmd_stop,
+        "cancel": _cmd_cancel,
         "status": _cmd_status,
         "voices": _cmd_voices,
         "welcome": _cmd_welcome,

{stackvox-0.9.0 → stackvox-0.11.0}/stackvox/daemon.py

@@ -5,8 +5,10 @@ Protocol: one JSON object per connection (line-terminated), reply is a status li
 
 Request shapes:
     {"text": "...", "voice": "af_sarah", "speed": 1.0, "lang": "en-us"}
-    {"command": "stop"}
+    {"command": "stop"}     # shut the daemon down
+    {"command": "cancel"}   # stop the current utterance, keep the daemon up
     {"command": "ping"}
+    {"command": "version"}
 
 Replies: "ok", "busy", "err: <msg>".
 """
@@ -203,6 +205,17 @@ class _DaemonState:
     def shutdown(self) -> None:
         self.stop_event.set()
 
+    def cancel(self) -> None:
+        """Stop the current utterance and drop anything queued, without shutting
+        the daemon down. Drains the queue first so the worker can't immediately
+        pick up a pending item, then aborts the in-flight playback."""
+        while True:
+            try:
+                self.queue.get_nowait()
+            except queue.Empty:
+                break
+        self.tts.stop()
+
 
 class _Handler(socketserver.StreamRequestHandler):
     def handle(self) -> None:
@@ -231,6 +244,11 @@ class _Handler(socketserver.StreamRequestHandler):
             threading.Thread(target=self.server.shutdown, daemon=True).start()
             return
 
+        if command == "cancel":
+            state.cancel()
+            self.wfile.write(b"ok\n")
+            return
+
         text = req.get("text")
         if not text:
             self.wfile.write(b"err: missing text\n")
@@ -345,6 +363,12 @@ def stop() -> tuple[bool, str]:
     return send({"command": "stop"})
 
 
+def cancel() -> tuple[bool, str]:
+    """Stop the daemon's current utterance (and drop the queue) without shutting
+    it down."""
+    return send({"command": "cancel"})
+
+
 def ping() -> tuple[bool, str]:
     return send({"command": "ping"}, timeout=PING_TIMEOUT_SECONDS)
 

{stackvox-0.9.0 → stackvox-0.11.0}/stackvox/text.py

@@ -20,6 +20,7 @@ __all__ = [
     "strip_thousands_separators",
     "versions_to_words",
     "decimals_to_words",
+    "speak_file_refs",
     "expand_units",
     "apply_pronunciations",
     "shape_pauses",
@@ -64,6 +65,7 @@ _UNIT_RULES: dict[str, list[tuple[str, str]]] = {
         (r"\s*÷\s*", " divided by "),
         (r"\s*×\s*", " times "),
         (r"\s*=\s*", " equals "),
+        (r"~\s*(?=\d)", "about "),  # ~123 -> "about 123" (else espeak says "tilde 123"); leaves ~/path alone
     ],
 }
 DEFAULT_LOCALE = "en-GB"
@@ -110,6 +112,46 @@ def decimals_to_words(text: str) -> str:
     )
 
 
+# --------------------------------------------------------------------------- #
+# File & line references                                                      #
+# --------------------------------------------------------------------------- #
+# `engine.py:42` reads as "…dot py colon forty two" — the dots and colon get
+# voiced literally. Spoken aloud the line number is the signal and the filename
+# is noise, so lead with "line N of <file>" (how a person actually says it) and
+# soften the path: drop directories to the basename, and voice the dotted name
+# word by word.
+
+_FILE_REF = re.compile(
+    r"(?<!\w)"
+    r"(?:[\w.-]*/)*"  # optional directory segments (dropped — "src/" reads as "slash")
+    r"([A-Za-z0-9_-]+(?:\.[A-Za-z][\w-]*)+)"  # filename with >=1 letter-initial extension
+    r":(\d+)(?:-(\d+))?(?::(\d+))?"  # :line, optional -end (range) or :column
+    r"(?!\w)"
+)
+
+
+def speak_file_refs(text: str) -> str:
+    """Turn ``path/file.ext:line`` refs into spoken "line N of file ext".
+
+    ``engine.py:42`` -> "line 42 of engine py"; ``cli.py:100-118`` -> "lines 100
+    to 118 of cli py"; ``foo.ts:666:10`` -> "line 666, column 10 of foo ts". The
+    ``:line`` suffix is the trigger, so bare times/ratios/verses (``12:30``,
+    ``3:1``, ``John 3:16``) and dotted versions (``1.2.3``) are left untouched —
+    none of them carry a dotted-filename before the colon.
+    """
+
+    def repl(match: re.Match[str]) -> str:
+        basename = match.group(1).replace(".", " ")
+        start, end, column = match.group(2), match.group(3), match.group(4)
+        if end:
+            location = f"lines {start} to {end}"
+        else:
+            location = f"line {start}" + (f", column {column}" if column else "")
+        return f"{location} of {basename}"
+
+    return _FILE_REF.sub(repl, text)
+
+
 # --------------------------------------------------------------------------- #
 # Pronunciations                                                              #
 # --------------------------------------------------------------------------- #
@@ -133,14 +175,22 @@ _DEV_PRONUNCIATIONS: dict[str, str] = {
     "cli": "C L I",
     "ci": "C I",
     "ide": "I D E",
-    "aws": "A W S",
+    "aws": "A.W.S.",  # dotted: espeak reads a lone "A" as the article "uh"; dots force the letter name "ay"
     "uri": "U R I",
-    "iam": "I A M",
+    "iam": "I.A.M.",  # ditto — the middle "A" needs the dot
     "saas": "sass",
     "paas": "pass",
     "tui": "T U I",
     "postgresql": "postgres",
     "kubectl": "kube control",
+    "stackone": "stack one",  # org name espeak garbles as "stac kone"
+    # "dedupe" glued reads as "de-dup" (short u); split + long "dee" gives "dee doop".
+    # Inflections listed explicitly — apply_pronunciations matches whole words only.
+    "dedupe": "dee dupe",
+    "deduped": "dee duped",
+    "deduping": "dee duping",
+    "dedupes": "dee dupes",
+    "dedup": "dee dupe",
 }
 
 
@@ -188,11 +238,24 @@ def _strip_md_inline(line: str) -> str:
     return line
 
 
-def markdown_to_paragraphs(text: str, *, tables: str = "drop", strip_emoji_flag: bool = False) -> list[str]:
+def markdown_to_paragraphs(
+    text: str,
+    *,
+    tables: str = "drop",
+    strip_emoji_flag: bool = False,
+    code_blocks: str = "drop",
+    code_placeholder: str = "",
+) -> list[str]:
     """Reduce Markdown to a list of speakable paragraphs. Headings and list
     items become their own paragraphs (so each gets its own pause). Tables are
-    dropped or rendered comma-separated per ``tables``."""
-    text = re.sub(r"(?ms)^[ \t]*(```|~~~).*?^[ \t]*\1[ \t]*$", "\n", text)  # fenced code
+    dropped or rendered comma-separated per ``tables``. Fenced code blocks are
+    dropped, or (``code_blocks="placeholder"``) replaced with a spoken
+    ``code_placeholder`` so a silently-skipped block doesn't sound disjointed."""
+    speak_code = code_blocks == "placeholder" and bool(code_placeholder)
+    # A function replacement keeps the placeholder literal (no backref parsing);
+    # blank lines around it make it a standalone paragraph.
+    fenced = f"\n\n{code_placeholder}\n\n" if speak_code else "\n"
+    text = re.sub(r"(?ms)^[ \t]*(```|~~~).*?^[ \t]*\1[ \t]*$", lambda _: fenced, text)  # fenced code
     text = re.sub(r"```+|~~~+", " ", text)  # stray fences
     if strip_emoji_flag:
         text = strip_emoji(text)
@@ -277,6 +340,14 @@ def markdown_to_paragraphs(text: str, *, tables: str = "drop", strip_emoji_flag:
             flush()
 
     flush()
+
+    if speak_code:  # collapse runs of adjacent code blocks into one placeholder
+        collapsed: list[str] = []
+        for para in paragraphs:
+            if para == code_placeholder and collapsed and collapsed[-1] == code_placeholder:
+                continue
+            collapsed.append(para)
+        return collapsed
     return paragraphs
 
 
@@ -289,11 +360,17 @@ def _shape_paragraph(
     text: str,
     *,
     pronunciations: dict[str, str] | None,
+    dev_terms_flag: bool,
     expand_units_flag: bool,
     expand_numbers_flag: bool,
     pauses_flag: bool,
     locale: str,
 ) -> str:
+    # File refs first: it consumes the ":line" digits (so the number stages see a
+    # plain "line 42", not a decimal) and forms the spoken basename before the
+    # dev-term dict runs over it.
+    if dev_terms_flag:
+        text = speak_file_refs(text)
     if expand_numbers_flag:
         text = strip_thousands_separators(text)
     if pauses_flag:
@@ -318,6 +395,8 @@ def normalize_for_speech(
     expand_numbers: bool = True,
     pauses: bool = True,
     tables: str = "drop",
+    code_blocks: str = "drop",
+    code_placeholder: str = "Code block.",
     strip_emoji: bool = False,
     terminal_stops: bool = True,
     locale: str = DEFAULT_LOCALE,
@@ -332,7 +411,13 @@ def normalize_for_speech(
         effective_pronunciations[written.lower()] = spoken
 
     if markdown:
-        paragraphs = markdown_to_paragraphs(text, tables=tables, strip_emoji_flag=strip_emoji)
+        paragraphs = markdown_to_paragraphs(
+            text,
+            tables=tables,
+            strip_emoji_flag=strip_emoji,
+            code_blocks=code_blocks,
+            code_placeholder=code_placeholder,
+        )
     else:
         # `strip_emoji` (the bool kwarg) shadows the module function here, so
         # reach for the underlying pattern directly.
@@ -344,6 +429,7 @@ def normalize_for_speech(
         shaped = _shape_paragraph(
             para,
             pronunciations=effective_pronunciations,
+            dev_terms_flag=dev_terms,
             expand_units_flag=expand_units_flag,
             expand_numbers_flag=expand_numbers_flag,
             pauses_flag=pauses,

{stackvox-0.9.0 → stackvox-0.11.0/stackvox.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stackvox
-Version: 0.9.0
+Version: 0.11.0
 Summary: Offline TTS library using Kokoro-82M
 Author-email: "StackOne Technologies Ltd." <support@stackone.com>
 License-Expression: Apache-2.0
@@ -103,7 +103,11 @@ stackvox speak --normalize --file post.md       # normalize, then synthesize
 stackvox say   --normalize "**Shipped** 1,198.9 MPG"   # normalize, then send to daemon
 ```
 
-`--normalize` is off by default on `speak`/`say`, so notification phrases synthesize exactly as before. The tuning flags mirror the library defaults (all on except emoji-strip): `--no-markdown`, `--no-expand-units`, `--no-expand-numbers`, `--no-pauses`, `--tables {drop,csv}`, `--strip-emoji`, `--no-terminal-stops`, `--locale`, and a `--pronunciations FILE` (a JSON `{"written": "spoken"}` map, applied whole-word and case-insensitively).
+`--normalize` is off by default on `speak`/`say`, so notification phrases synthesize exactly as before. The tuning flags mirror the library defaults (all on except emoji-strip): `--no-markdown`, `--no-dev-terms`, `--no-expand-units`, `--no-expand-numbers`, `--no-pauses`, `--tables {drop,csv}`, `--code-blocks {drop,placeholder}`, `--strip-emoji`, `--no-terminal-stops`, `--locale`, and a `--pronunciations FILE` (a JSON `{"written": "spoken"}` map, applied whole-word and case-insensitively).
+
+**Dev-output handling** (on by default; `--no-dev-terms` to disable) covers two things espeak reads badly: acronyms it says as words (`CLI` → "C L I", `AWS`, `URI`, `IAM`, …) and file-line references, which it voices literally as "dot py colon". A `file.ext:line` ref is re-spoken lead-with-the-line: `engine.py:42` → "line 42 of engine py", `cli.py:100-118` → "lines 100 to 118 of cli py", `foo.ts:666:10` → "line 666, column 10 of foo ts". Times, ratios, and versions (`12:30`, `3:1`, `1.2.3`) are left alone.
+
+Fenced code blocks are dropped by default. `--code-blocks placeholder` instead speaks a short stand-in so a skipped block doesn't sound disjointed (ChatGPT-style) — set the wording with `--code-placeholder` (e.g. `--code-blocks placeholder --code-placeholder "you can see the code in the chat history"`); consecutive blocks collapse to one.
 
 Bash completion:
 

{stackvox-0.9.0 → stackvox-0.11.0}/tests/test_cli.py

@@ -133,6 +133,8 @@ def _norm_ns(text=None, file=None, **overrides):
         expand_numbers=True,
         pauses=True,
         tables="drop",
+        code_blocks="drop",
+        code_placeholder="Code block.",
         strip_emoji=False,
         terminal_stops=True,
         locale="en-GB",
@@ -523,3 +525,37 @@ class TestNormalizeParsing:
         mocker.patch.object(cli.sys, "argv", ["stackvox", "paths"])
         assert cli.main() == 0
         assert paths_handler.called
+
+    def test_code_block_flags_parse(self, mocker):
+        norm = mocker.patch.object(cli, "_cmd_normalize", return_value=0)
+        mocker.patch.object(
+            cli.sys,
+            "argv",
+            [
+                "stackvox",
+                "normalize",
+                "--code-blocks",
+                "placeholder",
+                "--code-placeholder",
+                "see the chat",
+                "hi",
+            ],
+        )
+        assert cli.main() == 0
+        args = norm.call_args.args[0]
+        assert args.code_blocks == "placeholder"
+        assert args.code_placeholder == "see the chat"
+
+
+class TestCmdCancel:
+    def test_running_calls_daemon_cancel(self, mocker):
+        mocker.patch.object(cli.daemon, "is_running", return_value=True)
+        cancel = mocker.patch.object(cli.daemon, "cancel", return_value=(True, "ok"))
+        assert cli._cmd_cancel(_ns()) == 0
+        cancel.assert_called_once()
+
+    def test_no_daemon_is_a_noop(self, mocker):
+        mocker.patch.object(cli.daemon, "is_running", return_value=False)
+        cancel = mocker.patch.object(cli.daemon, "cancel")
+        assert cli._cmd_cancel(_ns()) == 0
+        cancel.assert_not_called()

{stackvox-0.9.0 → stackvox-0.11.0}/tests/test_daemon_protocol.py

@@ -169,3 +169,11 @@ def test_send_helper_when_daemon_not_running(tmp_path, monkeypatch):
     ok, resp = daemon.send({"command": "ping"})
     assert not ok
     assert resp == "daemon not running"
+
+
+def test_cancel_stops_playback_and_keeps_daemon_up(server: ServerHarness):
+    reply = _roundtrip(server.sock, json.dumps({"command": "cancel"}) + "\n")
+    assert reply == "ok"
+    server.tts.stop.assert_called()  # current utterance aborted
+    # unlike `stop`, the daemon stays up
+    assert _roundtrip(server.sock, json.dumps({"command": "ping"}) + "\n") == "ok"

{stackvox-0.9.0 → stackvox-0.11.0}/tests/test_text.py

@@ -8,6 +8,7 @@ from stackvox.text import (
     markdown_to_paragraphs,
     normalize_for_speech,
     shape_pauses,
+    speak_file_refs,
     strip_emoji,
     strip_thousands_separators,
     versions_to_words,
@@ -54,6 +55,44 @@ def test_semver_normalizes_end_to_end():
     assert "0 point 7.0" not in out
 
 
+# --- file & line references ------------------------------------------------
+
+
+def test_file_ref_leads_with_line_then_file():
+    assert speak_file_refs("unifiedAPIv2.service.ts:666") == "line 666 of unifiedAPIv2 service ts"
+
+
+def test_file_ref_drops_directories_to_basename():
+    assert speak_file_refs("Open /abs/path/to/module.py:7.") == "Open line 7 of module py."
+
+
+def test_file_ref_line_range():
+    assert speak_file_refs("cli.py:100-118") == "lines 100 to 118 of cli py"
+
+
+def test_file_ref_line_and_column():
+    assert speak_file_refs("foo.ts:666:10") == "line 666, column 10 of foo ts"
+
+
+def test_file_ref_leaves_times_ratios_verses_untouched():
+    text = "Meet at 12:30, the ratio was 3:1, see John 3:16."
+    assert speak_file_refs(text) == text
+
+
+def test_file_ref_leaves_dotted_versions_untouched():
+    assert speak_file_refs("bump to 1.2.3 and 0.7.0") == "bump to 1.2.3 and 0.7.0"
+
+
+def test_file_ref_normalizes_end_to_end():
+    out = normalize_for_speech("See `engine.py:42` for the fix.", markdown=True)
+    assert out == "See line 42 of engine py for the fix."
+
+
+def test_file_ref_disabled_with_dev_terms():
+    out = normalize_for_speech("See engine.py:42.", markdown=False, dev_terms=False)
+    assert out == "See engine.py:42."
+
+
 # --- units -----------------------------------------------------------------
 
 
@@ -74,6 +113,20 @@ def test_math_symbols():
     assert expand_units("770 ÷ 2 × 3 = 5").strip() == "770 divided by 2 times 3 equals 5"
 
 
+def test_tilde_before_number_is_approximately():
+    assert expand_units("~123") == "about 123"
+    assert expand_units("~ 50 items") == "about 50 items"
+
+
+def test_tilde_not_before_number_is_left_alone():
+    # home dir / approx-equal — not an approximated quantity
+    assert expand_units("~/projects") == "~/projects"
+
+
+def test_tilde_approx_end_to_end_with_decimal():
+    assert normalize_for_speech("took ~1.5 hours", markdown=False) == "took about 1 point 5 hours."
+
+
 def test_unknown_locale_falls_back_to_en_gb():
     assert expand_units("£5", locale="xx-YY") == "5 pounds"
 
@@ -136,6 +189,29 @@ def test_fenced_code_dropped():
     assert markdown_to_paragraphs(md) == ["Before.", "After."]
 
 
+def test_fenced_code_replaced_with_placeholder():
+    md = "Before.\n\n```py\nprint('hi')\n```\n\nAfter."
+    actual = markdown_to_paragraphs(md, code_blocks="placeholder", code_placeholder="see the code")
+    assert actual == ["Before.", "see the code", "After."]
+
+
+def test_consecutive_code_blocks_collapse_to_one_placeholder():
+    md = "```py\na\n```\n\n```py\nb\n```"
+    actual = markdown_to_paragraphs(md, code_blocks="placeholder", code_placeholder="see the code")
+    assert actual == ["see the code"]
+
+
+def test_code_placeholder_spoken_end_to_end():
+    md = "Here is how:\n\n```py\nx = 1\n```\n\nDone."
+    out = normalize_for_speech(md, code_blocks="placeholder", code_placeholder="see the chat history")
+    assert out == "Here is how:\nsee the chat history.\nDone."
+
+
+def test_code_blocks_dropped_by_default_end_to_end():
+    md = "Here is how:\n\n```py\nx = 1\n```\n\nDone."
+    assert normalize_for_speech(md) == "Here is how:\nDone."
+
+
 def test_tables_dropped_by_default():
     md = "| A | B |\n| --- | --- |\n| 1 | 2 |"
     assert markdown_to_paragraphs(md) == []
@@ -226,11 +302,17 @@ def test_plain_text_mode_splits_paragraphs():
 def test_dev_acronyms_are_spelled_out():
     assert normalize_for_speech("Use the CLI.", markdown=False) == "Use the C L I."
     assert "C L I" in normalize_for_speech("the cli tool", markdown=False)  # lowercase too
-    assert "A W S" in normalize_for_speech("deploy to AWS", markdown=False)
+    assert "A.W.S." in normalize_for_speech("deploy to AWS", markdown=False)  # dotted → "ay"
+    assert "I.A.M." in normalize_for_speech("set up IAM", markdown=False)
     assert "U R I" in normalize_for_speech("parse the URI", markdown=False)
     assert "C I C D" in normalize_for_speech("the CI/CD pipeline", markdown=False)
 
 
+def test_org_names_are_spoken_word_by_word():
+    assert "stack one" in normalize_for_speech("deployed to StackOne today", markdown=False)
+    assert "stack one" in normalize_for_speech("the stackone api", markdown=False)  # case-insensitive
+
+
 def test_dev_terms_leave_correctly_voiced_acronyms_alone():
     out = normalize_for_speech("Send JSON over HTTP to the API.", markdown=False)
     assert "JSON" in out
@@ -238,6 +320,18 @@ def test_dev_terms_leave_correctly_voiced_acronyms_alone():
     assert "API" in out
 
 
+def test_dedupe_respelled_for_speech():
+    assert normalize_for_speech("dedupe the list", markdown=False) == "dee dupe the list."
+    # inflections and case
+    assert "dee duped" in normalize_for_speech("we Deduped it", markdown=False)
+    assert "dee duping" in normalize_for_speech("deduping now", markdown=False)
+
+
+def test_dedupe_does_not_touch_other_words():
+    # whole-word only — must not rewrite the middle of a longer token
+    assert "dee dupe" not in normalize_for_speech("dedupelicated", markdown=False)
+
+
 def test_dev_terms_can_be_disabled():
     assert normalize_for_speech("Use the CLI.", markdown=False, dev_terms=False) == "Use the CLI."