diff --git a/.github/scripts/verify_package.py b/.github/scripts/verify_package.py
index f3b1cbb..d9fc5b3 100644
--- a/.github/scripts/verify_package.py
+++ b/.github/scripts/verify_package.py
@@ -12,6 +12,7 @@
 from pathlib import Path
 
 import imageio_ffmpeg
+from agent_voice.media import CONTENT_TYPES, generating_audio
 
 SERVICE_URL = "http://127.0.0.1:18765"
 
@@ -129,6 +130,9 @@ def main() -> None:
     output_dir = Path(os.environ["RUNNER_TEMP"]) / "agent-voice-package-e2e"
     output_dir.mkdir(parents=True, exist_ok=True)
 
+    for audio_format in CONTENT_TYPES:
+        assert generating_audio(audio_format)
+
     subprocess.run([str(cli), "setup", "--model", "int8"], check=True)
     offline_doctor = run_cli(cli, "doctor", "--service-url", SERVICE_URL, "--json")
     check_doctor(offline_doctor, "warn")
@@ -200,18 +204,27 @@ def main() -> None:
             )
             check_doctor(online_doctor, "pass")
 
-            service_wav = output_dir / "service.wav"
             remote = run_cli(
                 cli,
                 "speak",
                 f"{system} localhost service verification.",
                 "--service-url",
                 SERVICE_URL,
-                "--output",
-                str(service_wav),
+                "--label",
+                "Package Service E2E",
+                "--format",
+                "wav",
             )
+            service_wav = Path(str(remote["path"]))
             assert remote["backend"] == "service"
+            assert remote["generation"] == {"state": "started"}
+            assert "stream_url" in remote["delivery"]
             assert "playback" not in remote
+            pending = service_wav.with_name(f".{service_wav.name}.pending")
+            deadline = time.monotonic() + 120
+            while pending.is_file() and time.monotonic() < deadline:
+                time.sleep(0.1)
+            assert not pending.exists(), "background generation did not finish"
             validate_wav(service_wav)
         finally:
             service.terminate()
diff --git a/README.md b/README.md
index faf3e67..534c9e3 100644
--- a/README.md
+++ b/README.md
@@ -163,13 +163,8 @@ agent-voice speak "The build is finished."
 # Agent output through stdin
 printf '%s' "$TEXT" | agent-voice speak --label build-summary
 
-# Spoken response text and written response Markdown in one command
-agent-voice speak "$RESPONSE_AS_TEXT" \
-  --markdown "$RESPONSE_AS_MARKDOWN" --label response
-
-# Use separate files for a long spoken response and its written Markdown
-agent-voice speak --response-file "$RESPONSE_AS_MARKDOWN_FILE" \
-  < "$RESPONSE_AS_TEXT_FILE"
+# Use a file for a long spoken response
+agent-voice speak --label response < "$RESPONSE_AS_TEXT_FILE"
 
 # Choose the output and delivery
 agent-voice speak "Here is your summary." \
@@ -180,8 +175,6 @@ agent-voice speak "Here is your summary." \
 | --- | --- |
 | `-o, --output PATH` | Write to an exact path. |
 | `--label TEXT` | Set the managed filename prefix. |
-| `--markdown TEXT` | Show an inline Markdown response in the viewer. |
-| `--response-file PATH` | Show a Markdown response in the browser viewer. |
 | `--output-dir DIR` | Choose the managed output directory. |
 | `-f, --format FORMAT` | Use `wav`, `mp3`, `opus`, or `m4a`. |
 | `-v, --voice NAME` | Select a voice. |
@@ -190,12 +183,14 @@ agent-voice speak "Here is your summary." \
 | `-p, --play` | Start local playback after creation, without waiting for it to finish. |
 | `--play-after SECONDS` | Schedule local playback after creation, without waiting. |
 | `--controls` | Include experimental `agent-voice://` playback control links. |
+| `--wait` | Wait for the completed recording instead of returning live links. |
 | `--no-service` | Run the same Agent Voice model inside this command, then unload it. |
 | `--model-id ID`, `--variant NAME` | Select a model and build. |
 
-`speak` prints one JSON receipt with the absolute recording path, file URI,
-audio metadata, playback state (`started` or `scheduled`), and available viewer
-links. This makes the command reliable for both people and agents.
+`speak` prints one JSON receipt with the absolute recording path, generation
+state, audio metadata, playback state (`started` or `scheduled`), and available
+delivery links. By default it returns live links while generation continues;
+pass `--wait` when the completed file is required before the command returns.
 
 ### Configure defaults
 
@@ -258,11 +253,11 @@ agent-voice viewer stop
 The lightweight viewer starts automatically when needed and serves only local
 recordings. It prefers `http://127.0.0.1:8779` and selects a free port if that
 port is unavailable. Each managed recording keeps an editable `.txt` source
-beside it. At startup and every six hours, the viewer removes owned audio older
-than four days and 18 hours; files without Agent Voice source, transcript, and
-language metadata are left alone. Opening a player or audio URL regenerates
-missing audio from its source with the original language and current voice and
-speed.
+beside it. At startup and every hour, the viewer removes temporary live-stream
+audio older than one hour and owned recordings older than four days and 18
+hours; files without Agent Voice source, transcript, and language metadata are
+left alone. Opening a player or audio URL regenerates missing audio from its
+source with the original language and current voice and speed.
 
 Playback commands return as soon as local playback starts, or immediately with
 `scheduled` when a delay is requested; they never wait for the recording to end.
diff --git a/THIRD_PARTY_NOTICES.md b/THIRD_PARTY_NOTICES.md
index 127ea3a..43d9f42 100644
--- a/THIRD_PARTY_NOTICES.md
+++ b/THIRD_PARTY_NOTICES.md
@@ -8,6 +8,3 @@ This project depends on third-party software and downloads model assets.
 - **imageio-ffmpeg** — Copyright imageio-ffmpeg contributors, licensed under the BSD 2-Clause License. Its platform wheels include an FFmpeg executable: <https://github.com/imageio/imageio-ffmpeg>
 - **FFmpeg** — The executable bundled by imageio-ffmpeg is licensed under GNU GPL version 2 or later. License and source information: <https://ffmpeg.org/legal.html>
 - **miniaudio Python bindings** — Copyright Irmen de Jong and contributors, licensed under the MIT License: <https://github.com/irmen/pyminiaudio>
-- **linkify-it-py and uc-micro-py** — Copyright their contributors, licensed under the MIT License: <https://github.com/tsutsu3/linkify-it-py>
-- **markdown-it-py and mdurl** — Copyright their contributors, licensed under the MIT License: <https://github.com/executablebooks/markdown-it-py>
-- **Pygments** — Copyright Georg Brandl and contributors, licensed under the BSD 2-Clause License: <https://pygments.org>
diff --git a/pyproject.toml b/pyproject.toml
index 1e6a326..722bd10 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,6 +1,6 @@
 [project]
 name = "agent-voice"
-version = "0.8.0"
+version = "0.9.0"
 description = "Local, free voice artifacts for AI agents"
 readme = "README.md"
 requires-python = ">=3.11,<3.14"
@@ -24,11 +24,8 @@ dependencies = [
   "filelock>=3.20,<4",
   "imageio-ffmpeg==0.6.0",
   "kokoro-onnx==0.5.0",
-  "linkify-it-py>=2,<3",
-  "markdown-it-py>=4.2,<5",
   "miniaudio==1.71",
   "numpy>=2,<3",
-  "pygments>=2.19,<3",
 ]
 
 [project.urls]
diff --git a/skills/create-speech-recording-controls/SKILL.md b/skills/create-speech-recording-controls/SKILL.md
index d0ef6f3..0142220 100644
--- a/skills/create-speech-recording-controls/SKILL.md
+++ b/skills/create-speech-recording-controls/SKILL.md
@@ -10,10 +10,7 @@ matching voice with `agent-voice voices` and pass `--voice` and `--lang`.
 
 ## Prepare
 
-Set `RESPONSE_AS_MARKDOWN` to the original text or Markdown. Set
-`RESPONSE_AS_TEXT` to its spoken form. Never use `RESPONSE_AS_MARKDOWN` as the
-speech input.
-Use real line breaks in `RESPONSE_AS_MARKDOWN`, not escaped `\n` text.
+Set `RESPONSE_AS_TEXT` to the text's spoken form.
 
 - For supplied text, preserve every word and punctuation mark in order while
   translating presentation syntax into speech.
@@ -24,13 +21,13 @@ Use real line breaks in `RESPONSE_AS_MARKDOWN`, not escaped `\n` text.
 ## Record
 
 ```sh
-agent-voice speak "$RESPONSE_AS_TEXT" --markdown "$RESPONSE_AS_MARKDOWN" --controls
+agent-voice speak "$RESPONSE_AS_TEXT" --controls
 ```
 
 For long text, use temporary files outside the workspace and remove them afterward:
 
 ```sh
-agent-voice speak --label "$LABEL" --response-file "$RESPONSE_AS_MARKDOWN_FILE" --controls < "$RESPONSE_AS_TEXT_FILE"
+agent-voice speak --label "$LABEL" --controls < "$RESPONSE_AS_TEXT_FILE"
 ```
 
 Set `LABEL` to a short subject. For an exact requested filename, replace
@@ -42,7 +39,8 @@ blocking.
 
 ## Deliver
 
-Use [default.md](references/delivery/default.md).
+Use [default.md](references/delivery/default.md) immediately after `speak`
+returns a receipt with generation.state: "started"
 
 ## Setup
 
diff --git a/skills/create-speech-recording-desktop/SKILL.md b/skills/create-speech-recording-desktop/SKILL.md
index 522fcf6..811870e 100644
--- a/skills/create-speech-recording-desktop/SKILL.md
+++ b/skills/create-speech-recording-desktop/SKILL.md
@@ -10,10 +10,7 @@ matching voice with `agent-voice voices` and pass `--voice` and `--lang`.
 
 ## Prepare
 
-Set `RESPONSE_AS_MARKDOWN` to the original text or Markdown. Set
-`RESPONSE_AS_TEXT` to its spoken form. Never use `RESPONSE_AS_MARKDOWN` as the
-speech input.
-Use real line breaks in `RESPONSE_AS_MARKDOWN`, not escaped `\n` text.
+Set `RESPONSE_AS_TEXT` to the text's spoken form.
 
 - For supplied text, preserve every word and punctuation mark in order while
   translating presentation syntax into speech.
@@ -24,23 +21,23 @@ Use real line breaks in `RESPONSE_AS_MARKDOWN`, not escaped `\n` text.
 ## Record
 
 ```sh
-agent-voice speak "$RESPONSE_AS_TEXT" --markdown "$RESPONSE_AS_MARKDOWN"
+agent-voice speak "$RESPONSE_AS_TEXT" --wait
 ```
 
 For long text, use temporary files outside the workspace and remove them afterward:
 
 ```sh
-agent-voice speak --label "$LABEL" --response-file "$RESPONSE_AS_MARKDOWN_FILE" < "$RESPONSE_AS_TEXT_FILE"
+agent-voice speak --label "$LABEL" --wait < "$RESPONSE_AS_TEXT_FILE"
 ```
 
-On Antigravity App, follow the special
+On OpenCode Desktop, omit `--wait`. On Antigravity App, follow the special
 [recording and delivery instructions](references/delivery/antigravity.md).
 
 Set `LABEL` to a short subject. For an exact requested filename, replace
 `--label "$LABEL"` with `--output "$PATH"`.
 
-Use the returned `path` to deliver the recording. For speaker playback, add
-`-p`; continue after the result reports `playback.state: "started"`. Add
+Use the matching delivery reference. For speaker playback, add `-p`; continue
+after the result reports `playback.state: "started"`. Add
 `--play-after SECONDS` to schedule it without blocking.
 
 ## Deliver
diff --git a/skills/create-speech-recording-desktop/references/delivery/opencode-desktop.md b/skills/create-speech-recording-desktop/references/delivery/opencode-desktop.md
index 8f7c259..f0424f5 100644
--- a/skills/create-speech-recording-desktop/references/delivery/opencode-desktop.md
+++ b/skills/create-speech-recording-desktop/references/delivery/opencode-desktop.md
@@ -1,15 +1,16 @@
 # OpenCode Desktop
 
 Set `PLAYER_ID` to a unique lowercase ID. Set `RECORDING_NAME` to the basename
-of the returned `path`. Set `audio_url` to `delivery.audio_url`. Replace the
-placeholders in the template. Render the HTML directly without the code fence.
+of `path`. Set `AUDIO_SOURCE` to `delivery.stream_url` when present, otherwise
+to `delivery.audio_url`. Replace the placeholders and render the HTML directly
+without the code fence.
 
 ```html
 <div id="$PLAYER_ID" style="box-sizing:border-box;width:min(100%,520px);margin:0 0 1.125rem;color:CanvasText;color-scheme:light dark">
   <div style="margin:0 0 .375rem;font:700 16px/1.2 ui-sans-serif,system-ui,-apple-system,sans-serif;letter-spacing:-.01em;color:CanvasText">$RECORDING_NAME</div>
   <div style="display:flex;align-items:center;gap:12px;min-width:0">
-    <audio controls preload="metadata" src="$audio_url" style="display:block;min-width:0;width:100%;height:42px">
-      <a href="$audio_url">Play recording</a>
+    <audio controls preload="auto" src="$AUDIO_SOURCE" style="display:block;min-width:0;width:100%;height:42px">
+      <a href="$AUDIO_SOURCE">Play recording</a>
     </audio>
     <svg viewBox="0 0 100 100" role="img" aria-label="Agent Voice" style="display:block;flex:0 0 42px;width:42px;height:42px;fill:none;stroke:#ff6037;stroke-width:4;stroke-linecap:round;stroke-linejoin:round">
       <path d="M8 52h4c3 0 3-7 6-7s3 13 6 13c4 0 4-25 8-25s5 35 10 35c5 0 5-37 10-37s4 31 8 31c3 0 3-16 6-16s3 6 6 6" style="stroke-width:4.5"/>
diff --git a/skills/create-speech-recording/SKILL.md b/skills/create-speech-recording/SKILL.md
index 34fbfe5..d05e06c 100644
--- a/skills/create-speech-recording/SKILL.md
+++ b/skills/create-speech-recording/SKILL.md
@@ -10,10 +10,7 @@ matching voice with `agent-voice voices` and pass `--voice` and `--lang`.
 
 ## Prepare
 
-Set `RESPONSE_AS_MARKDOWN` to the original text or Markdown. Set
-`RESPONSE_AS_TEXT` to its spoken form. Never use `RESPONSE_AS_MARKDOWN` as the
-speech input.
-Use real line breaks in `RESPONSE_AS_MARKDOWN`, not escaped `\n` text.
+Set `RESPONSE_AS_TEXT` to the text's spoken form.
 
 - For supplied text, preserve every word and punctuation mark in order while
   translating presentation syntax into speech.
@@ -24,13 +21,13 @@ Use real line breaks in `RESPONSE_AS_MARKDOWN`, not escaped `\n` text.
 ## Record
 
 ```sh
-agent-voice speak "$RESPONSE_AS_TEXT" --markdown "$RESPONSE_AS_MARKDOWN"
+agent-voice speak "$RESPONSE_AS_TEXT"
 ```
 
 For long text, use temporary files outside the workspace and remove them afterward:
 
 ```sh
-agent-voice speak --label "$LABEL" --response-file "$RESPONSE_AS_MARKDOWN_FILE" < "$RESPONSE_AS_TEXT_FILE"
+agent-voice speak --label "$LABEL" < "$RESPONSE_AS_TEXT_FILE"
 ```
 
 Set `LABEL` to a short subject. For an exact requested filename, replace
@@ -42,7 +39,8 @@ Use the returned `path` to deliver the recording. For speaker playback, add
 
 ## Deliver
 
-Use [default.md](references/delivery/default.md).
+Use [default.md](references/delivery/default.md) immediately after `speak`
+returns a receipt with generation.state: "started"
 
 ## Setup
 
diff --git a/skills/create-speech-recording/references/delivery/default.md b/skills/create-speech-recording/references/delivery/default.md
index 7782826..bf113d8 100644
--- a/skills/create-speech-recording/references/delivery/default.md
+++ b/skills/create-speech-recording/references/delivery/default.md
@@ -13,7 +13,7 @@ fence exactly as shown. Send the block without the outer four-backtick fence.
 
 Agent Voice recording
 
-Listen: [web player]($browser_url) · [media app]($file_uri) · [web audio]($audio_url)
+Listen: [web player]($browser_url) · [media app]($file_uri)
 
 Or run in the terminal
 
diff --git a/skills/spoken-response-controls/SKILL.md b/skills/spoken-response-controls/SKILL.md
index 761f556..9a772fb 100644
--- a/skills/spoken-response-controls/SKILL.md
+++ b/skills/spoken-response-controls/SKILL.md
@@ -1,11 +1,11 @@
 ---
 name: spoken-response-controls
-description: Create the spoken semantic twin of an assistant response with clickable Agent Voice playback controls. Use when the user explicitly requests controlled playback on a compatible desktop renderer.
+description: Read an assistant response aloud with clickable Agent Voice playback controls. Use when the user explicitly requests controlled playback on a compatible desktop renderer.
 ---
 
 # Spoken Response Controls
 
-A spoken response is the audio semantic twin of an assistant response.
+A spoken response reads the assistant response aloud without rewriting it.
 
 ## Mode
 
@@ -22,31 +22,29 @@ Choose the mode from the user's request:
 1. Select the response:
    - For `Single` and `Thread`, finalize the current response.
    - For `Previous`, use the most recent assistant response.
-2. Set `RESPONSE_AS_MARKDOWN` to the selected response's Markdown. Use real line
-   breaks, not escaped `\n` text.
-3. Set `RESPONSE_AS_TEXT` to its spoken semantic twin: preserve meaning, detail,
-   and order while translating formatting into natural speech. Never use
-   `RESPONSE_AS_MARKDOWN` as the speech input.
-   - For tables, state the headers once and read each row as labeled values.
-   - For long code, explain it naturally and refer to the written response for
-     exact syntax.
-4. Set `LABEL` to `SR`. When a thread title is already available, use
+2. Set `RESPONSE_AS_TEXT` to a read-aloud copy:
+   - **Fidelity:** preserve wording and order; do not summarize or rephrase.
+   - **Non-prose:** translate formatting and read tables naturally. Explain code
+     or visuals when useful; otherwise briefly introduce them ("Here is the
+     code" or "See the diagram below") and continue.
+3. Set `LABEL` to `SR`. When a thread title is already available, use
    `<title> - SR`.
-5. Create the recording with the configured voice, speed, and format:
+4. Create the recording with the configured voice, speed, and format:
 
    ```sh
-   agent-voice speak "$RESPONSE_AS_TEXT" --markdown "$RESPONSE_AS_MARKDOWN" --label "$LABEL" --controls
+   agent-voice speak "$RESPONSE_AS_TEXT" --label "$LABEL" --controls
    ```
 
    For long responses, use temporary files outside the workspace and remove them
    afterward:
 
    ```sh
-   agent-voice speak --label "$LABEL" --response-file "$RESPONSE_AS_MARKDOWN_FILE" --controls < "$RESPONSE_AS_TEXT_FILE"
+   agent-voice speak --label "$LABEL" --controls < "$RESPONSE_AS_TEXT_FILE"
    ```
 
-6. Place the controls above the written response or `Previous` confirmation using
-   [default.md](references/delivery/default.md).
+5. Place the controls above the written response or `Previous` confirmation using
+   [default.md](references/delivery/default.md) immediately after `speak`
+returns a receipt with generation.state: "started"
 
 For speaker playback, add `-p` and continue after the result reports
 `playback.state: "started"`. Add `--play-after SECONDS` to schedule it without
diff --git a/skills/spoken-response-desktop/SKILL.md b/skills/spoken-response-desktop/SKILL.md
index 6ab3f56..9283164 100644
--- a/skills/spoken-response-desktop/SKILL.md
+++ b/skills/spoken-response-desktop/SKILL.md
@@ -1,11 +1,11 @@
 ---
 name: spoken-response-desktop
-description: Create and embed the spoken semantic twin of a response in Codex Desktop, Antigravity App, or OpenCode Desktop.
+description: Read and embed an assistant response aloud in Codex Desktop, Antigravity App, or OpenCode Desktop.
 ---
 
 # Spoken Response Desktop
 
-A spoken response is the audio semantic twin of an assistant response.
+A spoken response reads the assistant response aloud without rewriting it.
 
 ## Mode
 
@@ -22,32 +22,31 @@ Choose the mode from the user's request:
 1. Select the response:
    - For `Single` and `Thread`, finalize the current response.
    - For `Previous`, use the most recent assistant response.
-2. Set `RESPONSE_AS_MARKDOWN` to the selected response's Markdown. Use real line
-   breaks, not escaped `\n` text.
-3. Set `RESPONSE_AS_TEXT` to its spoken semantic twin: preserve meaning, detail,
-   and order while translating formatting into natural speech. Never use
-   `RESPONSE_AS_MARKDOWN` as the speech input.
-   - For tables, state the headers once and read each row as labeled values.
-   - For long code, explain it naturally and refer to the written response for
-     exact syntax.
-4. Set `LABEL` to `SR`. When a thread title is already available, use
+2. Set `RESPONSE_AS_TEXT` to a read-aloud copy:
+   - **Fidelity:** preserve wording and order; do not summarize or rephrase.
+   - **Non-prose:** translate formatting and read tables naturally. Explain code
+     or visuals when useful; otherwise briefly introduce them ("Here is the
+     code" or "See the diagram below") and continue.
+3. Set `LABEL` to `SR`. When a thread title is already available, use
    `<title> - SR`.
-5. Create the recording with the configured voice, speed, and format. On
+4. Create the recording with the configured voice, speed, and format. On
    Antigravity App, follow the special
    [recording and delivery instructions](references/delivery/antigravity.md).
 
    ```sh
-   agent-voice speak "$RESPONSE_AS_TEXT" --markdown "$RESPONSE_AS_MARKDOWN" --label "$LABEL"
+   agent-voice speak "$RESPONSE_AS_TEXT" --label "$LABEL" --wait
    ```
 
    For long responses, use temporary files outside the workspace and remove them
    afterward:
 
    ```sh
-   agent-voice speak --label "$LABEL" --response-file "$RESPONSE_AS_MARKDOWN_FILE" < "$RESPONSE_AS_TEXT_FILE"
+   agent-voice speak --label "$LABEL" --wait < "$RESPONSE_AS_TEXT_FILE"
    ```
 
-6. Place the audio above the written response or `Previous` confirmation. Use
+   On OpenCode Desktop, omit `--wait` and go straight to the delivery reference.
+
+5. Place the audio above the written response or `Previous` confirmation. Use
    the first matching delivery reference:
    - Antigravity App: [antigravity.md](references/delivery/antigravity.md)
    - OpenCode Desktop: [opencode-desktop.md](references/delivery/opencode-desktop.md)
diff --git a/skills/spoken-response-desktop/references/delivery/opencode-desktop.md b/skills/spoken-response-desktop/references/delivery/opencode-desktop.md
index 8f7c259..f0424f5 100644
--- a/skills/spoken-response-desktop/references/delivery/opencode-desktop.md
+++ b/skills/spoken-response-desktop/references/delivery/opencode-desktop.md
@@ -1,15 +1,16 @@
 # OpenCode Desktop
 
 Set `PLAYER_ID` to a unique lowercase ID. Set `RECORDING_NAME` to the basename
-of the returned `path`. Set `audio_url` to `delivery.audio_url`. Replace the
-placeholders in the template. Render the HTML directly without the code fence.
+of `path`. Set `AUDIO_SOURCE` to `delivery.stream_url` when present, otherwise
+to `delivery.audio_url`. Replace the placeholders and render the HTML directly
+without the code fence.
 
 ```html
 <div id="$PLAYER_ID" style="box-sizing:border-box;width:min(100%,520px);margin:0 0 1.125rem;color:CanvasText;color-scheme:light dark">
   <div style="margin:0 0 .375rem;font:700 16px/1.2 ui-sans-serif,system-ui,-apple-system,sans-serif;letter-spacing:-.01em;color:CanvasText">$RECORDING_NAME</div>
   <div style="display:flex;align-items:center;gap:12px;min-width:0">
-    <audio controls preload="metadata" src="$audio_url" style="display:block;min-width:0;width:100%;height:42px">
-      <a href="$audio_url">Play recording</a>
+    <audio controls preload="auto" src="$AUDIO_SOURCE" style="display:block;min-width:0;width:100%;height:42px">
+      <a href="$AUDIO_SOURCE">Play recording</a>
     </audio>
     <svg viewBox="0 0 100 100" role="img" aria-label="Agent Voice" style="display:block;flex:0 0 42px;width:42px;height:42px;fill:none;stroke:#ff6037;stroke-width:4;stroke-linecap:round;stroke-linejoin:round">
       <path d="M8 52h4c3 0 3-7 6-7s3 13 6 13c4 0 4-25 8-25s5 35 10 35c5 0 5-37 10-37s4 31 8 31c3 0 3-16 6-16s3 6 6 6" style="stroke-width:4.5"/>
diff --git a/skills/spoken-response/SKILL.md b/skills/spoken-response/SKILL.md
index aea66c1..daf24de 100644
--- a/skills/spoken-response/SKILL.md
+++ b/skills/spoken-response/SKILL.md
@@ -1,11 +1,11 @@
 ---
 name: spoken-response
-description: Create the spoken semantic twin of an assistant response with Agent Voice. Use when the user requests a spoken response, the previous response as audio, or spoken responses for a thread.
+description: Read an assistant response aloud with Agent Voice. Use when the user requests a spoken response, the previous response as audio, or spoken responses for a thread.
 ---
 
 # Spoken Response
 
-A spoken response is the audio semantic twin of an assistant response.
+A spoken response reads the assistant response aloud without rewriting it.
 
 ## Mode
 
@@ -22,31 +22,29 @@ Choose the mode from the user's request:
 1. Select the response:
    - For `Single` and `Thread`, finalize the current response.
    - For `Previous`, use the most recent assistant response.
-2. Set `RESPONSE_AS_MARKDOWN` to the selected response's Markdown. Use real line
-   breaks, not escaped `\n` text.
-3. Set `RESPONSE_AS_TEXT` to its spoken semantic twin: preserve meaning, detail,
-   and order while translating formatting into natural speech. Never use
-   `RESPONSE_AS_MARKDOWN` as the speech input.
-   - For tables, state the headers once and read each row as labeled values.
-   - For long code, explain it naturally and refer to the written response for
-     exact syntax.
-4. Set `LABEL` to `SR`. When a thread title is already available, use
+2. Set `RESPONSE_AS_TEXT` to a read-aloud copy:
+   - **Fidelity:** preserve wording and order; do not summarize or rephrase.
+   - **Non-prose:** translate formatting and read tables naturally. Explain code
+     or visuals when useful; otherwise briefly introduce them ("Here is the
+     code" or "See the diagram below") and continue.
+3. Set `LABEL` to `SR`. When a thread title is already available, use
    `<title> - SR`.
-5. Create the recording with the configured voice, speed, and format:
+4. Create the recording with the configured voice, speed, and format:
 
    ```sh
-   agent-voice speak "$RESPONSE_AS_TEXT" --markdown "$RESPONSE_AS_MARKDOWN" --label "$LABEL"
+   agent-voice speak "$RESPONSE_AS_TEXT" --label "$LABEL"
    ```
 
    For long responses, use temporary files outside the workspace and remove them
    afterward:
 
    ```sh
-   agent-voice speak --label "$LABEL" --response-file "$RESPONSE_AS_MARKDOWN_FILE" < "$RESPONSE_AS_TEXT_FILE"
+   agent-voice speak --label "$LABEL" < "$RESPONSE_AS_TEXT_FILE"
    ```
 
-6. Place the audio above the written response or `Previous` confirmation using
-   [default.md](references/delivery/default.md).
+5. Place the audio above the written response or `Previous` confirmation using
+   [default.md](references/delivery/default.md) immediately after `speak`
+returns a receipt with generation.state: "started"
 
 For speaker playback, add `-p` and continue after the result reports
 `playback.state: "started"`. Add `--play-after SECONDS` to schedule it without
diff --git a/skills/spoken-response/references/delivery/default.md b/skills/spoken-response/references/delivery/default.md
index 7782826..bf113d8 100644
--- a/skills/spoken-response/references/delivery/default.md
+++ b/skills/spoken-response/references/delivery/default.md
@@ -13,7 +13,7 @@ fence exactly as shown. Send the block without the outer four-backtick fence.
 
 Agent Voice recording
 
-Listen: [web player]($browser_url) · [media app]($file_uri) · [web audio]($audio_url)
+Listen: [web player]($browser_url) · [media app]($file_uri)
 
 Or run in the terminal
 
diff --git a/src/agent_voice/__init__.py b/src/agent_voice/__init__.py
index 5c80027..d5ddaef 100644
--- a/src/agent_voice/__init__.py
+++ b/src/agent_voice/__init__.py
@@ -1,3 +1,3 @@
 """Local voice artifacts for AI agents."""
 
-__version__ = "0.8.0"
+__version__ = "0.9.0"
diff --git a/src/agent_voice/audio.py b/src/agent_voice/audio.py
index 6b7c25f..4fa6858 100644
--- a/src/agent_voice/audio.py
+++ b/src/agent_voice/audio.py
@@ -4,6 +4,7 @@
 import subprocess
 import tempfile
 import threading
+import time
 import wave
 from collections.abc import Generator
 from dataclasses import dataclass
@@ -16,6 +17,7 @@
 from numpy.typing import NDArray
 
 from .config import FORMATS, MAX_SPEED, MIN_SPEED
+from .paths import pending_generation_path, streaming_pcm_path
 
 PLAYBACK_SAMPLE_RATE = 24_000
 PLAYBACK_CHANNELS = 1
@@ -75,13 +77,16 @@ def __init__(
         self._command_lock = threading.Lock()
         self._lock = threading.Lock()
         self._recording: Path | None = None
-        self._source_pcm = b""
-        self._pcm = b""
+        self._source_pcm: bytes | bytearray = b""
+        self._pcm: bytes | bytearray = b""
         self._offset = 0
         self._speed = 1.0
         self._playing = False
         self._closed = False
         self._silence = b""
+        self._stream_path: Path | None = None
+        self._stream_token = 0
+        self._retiming = False
         self._device: miniaudio.PlaybackDevice | None = None
         self._stream: Generator[bytes | memoryview, int, None] | None = None
 
@@ -95,8 +100,15 @@ def control(self, recording: Path, action: str) -> PlaybackState:
                 raise RuntimeError("Playback controller is closed")
             with self._lock:
                 changed = self._recording != path
+                if changed:
+                    self._stream_token += 1
             if changed:
-                pcm = self._decoder(path)
+                pending = pending_generation_path(path)
+                stream_path = streaming_pcm_path(path)
+                streaming = pending.is_file() and stream_path.is_file()
+                pcm: bytes | bytearray = (
+                    bytearray() if streaming else self._decoder(path)
+                )
                 with self._lock:
                     self._recording = path
                     self._source_pcm = pcm
@@ -104,6 +116,10 @@ def control(self, recording: Path, action: str) -> PlaybackState:
                     self._offset = 0
                     self._speed = 1.0
                     self._playing = False
+                    self._stream_path = stream_path if streaming else None
+                    stream_token = self._stream_token
+                if streaming:
+                    self._start_stream_worker(path, stream_path, stream_token)
 
             if action in ("slower", "faster"):
                 with self._lock:
@@ -112,41 +128,70 @@ def control(self, recording: Path, action: str) -> PlaybackState:
                     speed = PLAYBACK_SPEEDS[
                         min(max(0, index + step), len(PLAYBACK_SPEEDS) - 1)
                     ]
-                    source_pcm = self._source_pcm
+                    source_pcm = bytes(self._source_pcm)
                     current_speed = self._speed
+                    streaming = self._stream_path is not None
+                    if speed != current_speed and streaming:
+                        self._retiming = True
                 if speed != current_speed:
                     # ponytail: rebuild one full PCM buffer per speed click; cache
                     # variants only if real recordings make latency or memory hurt.
-                    pcm = self._tempo_changer(source_pcm, speed)
+                    try:
+                        pcm = (
+                            self._tempo_changer(source_pcm, speed)
+                            if source_pcm
+                            else b""
+                        )
+                    except Exception:
+                        with self._lock:
+                            self._retiming = False
+                        raise
                     with self._lock:
                         source_offset = self._source_offset()
-                        self._pcm = pcm
+                        self._pcm = (
+                            self._source_pcm
+                            if speed == 1.0
+                            else bytearray(pcm)
+                            if streaming
+                            else pcm
+                        )
                         self._speed = speed
                         self._offset = self._playback_offset(source_offset)
-                        if self._offset >= len(self._pcm):
+                        self._retiming = False
+                        if (
+                            self._offset >= len(self._pcm)
+                            and not self._streaming_locked()
+                        ):
                             self._playing = False
 
             with self._lock:
                 if action == "toggle":
-                    if self._offset >= len(self._pcm):
+                    if self._offset >= len(self._pcm) and not self._streaming_locked():
                         self._offset = 0
                     self._playing = True if changed else not self._playing
                 elif action == "restart":
                     self._offset = 0
                     self._playing = True
                 elif action in ("back", "forward"):
-                    seconds = (
-                        -PLAYBACK_SEEK_SECONDS
-                        if action == "back"
-                        else PLAYBACK_SEEK_SECONDS
+                    delta = (
+                        PLAYBACK_SEEK_SECONDS
+                        * PLAYBACK_SAMPLE_RATE
+                        * PLAYBACK_SAMPLE_WIDTH
                     )
-                    delta = seconds * PLAYBACK_SAMPLE_RATE * PLAYBACK_SAMPLE_WIDTH
-                    source_offset = min(
-                        max(0, self._source_offset() + delta), len(self._source_pcm)
-                    )
-                    self._offset = self._playback_offset(source_offset)
-                    if source_offset >= len(self._source_pcm):
-                        self._playing = False
+                    source_offset = self._source_offset()
+                    target = source_offset + (delta if action == "forward" else -delta)
+                    if (
+                        action == "back"
+                        or target <= len(self._source_pcm)
+                        or self._streaming_locked()
+                    ):
+                        source_offset = min(max(0, target), len(self._source_pcm))
+                        self._offset = self._playback_offset(source_offset)
+                        if (
+                            source_offset >= len(self._source_pcm)
+                            and not self._streaming_locked()
+                        ):
+                            self._playing = False
                 playing = self._playing
             try:
                 self._sync_device(playing)
@@ -158,6 +203,9 @@ def control(self, recording: Path, action: str) -> PlaybackState:
                     self._offset = 0
                     self._speed = 1.0
                     self._playing = False
+                    self._stream_path = None
+                    self._stream_token += 1
+                    self._retiming = False
                 raise
             with self._lock:
                 return self._state()
@@ -167,6 +215,9 @@ def close(self) -> None:
             self._closed = True
             with self._lock:
                 self._playing = False
+                self._stream_path = None
+                self._stream_token += 1
+                self._retiming = False
             self._discard_device()
 
     def _sync_device(self, playing: bool) -> None:
@@ -225,19 +276,96 @@ def _chunks(self) -> Generator[bytes | memoryview, int, None]:
                 if self._playing and self._offset < len(self._pcm):
                     start = self._offset
                     self._offset = min(start + requested_bytes, len(self._pcm))
-                    chunk: bytes | memoryview = memoryview(self._pcm)[
-                        start : self._offset
-                    ]
-                    if self._offset >= len(self._pcm):
+                    chunk: bytes | memoryview = bytes(self._pcm[start : self._offset])
+                    if self._offset >= len(self._pcm) and not self._streaming_locked():
                         # ponytail: completion feeds silence; add an idle monitor if
                         # holding the audio device becomes a real resource problem.
                         self._playing = False
                 else:
+                    if self._playing and not self._streaming_locked():
+                        self._playing = False
                     if len(self._silence) < requested_bytes:
                         self._silence = bytes(requested_bytes)
                     chunk = memoryview(self._silence)[:requested_bytes]
             required_frames = yield chunk
 
+    def _start_stream_worker(
+        self, recording: Path, stream_path: Path, token: int
+    ) -> None:
+        thread = threading.Thread(
+            target=self._consume_stream,
+            args=(recording, stream_path, token),
+            daemon=True,
+            name="agent-voice-stream",
+        )
+        thread.start()
+
+    def _consume_stream(self, recording: Path, stream_path: Path, token: int) -> None:
+        offset = 0
+        try:
+            with stream_path.open("rb") as stream:
+                while True:
+                    with self._lock:
+                        if token != self._stream_token:
+                            return
+                        retiming = self._retiming
+                        speed = self._speed
+                    if retiming:
+                        time.sleep(0.05)
+                        continue
+
+                    stream.seek(offset)
+                    chunk = stream.read()
+                    if chunk:
+                        changed = (
+                            chunk if speed == 1.0 else self._tempo_changer(chunk, speed)
+                        )
+                        with self._lock:
+                            if token != self._stream_token:
+                                return
+                            if self._retiming or speed != self._speed:
+                                continue
+                            source = self._source_pcm
+                            if not isinstance(source, bytearray):
+                                return
+                            source.extend(chunk)
+                            if self._pcm is not source:
+                                if not isinstance(self._pcm, bytearray):
+                                    return
+                                self._pcm.extend(changed)
+                            offset += len(chunk)
+                    elif pending_generation_path(recording).is_file():
+                        time.sleep(0.05)
+                    else:
+                        try:
+                            completed = (
+                                recording.is_file() and recording.stat().st_size > 0
+                            )
+                        except OSError:
+                            completed = False
+                        with self._lock:
+                            if token == self._stream_token:
+                                self._stream_path = None
+                                if not completed:
+                                    self._recording = None
+                                    self._source_pcm = b""
+                                    self._pcm = b""
+                                    self._offset = 0
+                                    self._playing = False
+                        return
+        except Exception:
+            with self._lock:
+                if token == self._stream_token:
+                    self._stream_path = None
+                    self._recording = None
+                    self._source_pcm = b""
+                    self._pcm = b""
+                    self._offset = 0
+                    self._playing = False
+
+    def _streaming_locked(self) -> bool:
+        return self._stream_path is not None
+
     def _state(self) -> PlaybackState:
         if self._recording is None:
             raise RuntimeError("No recording is loaded")
@@ -345,12 +473,17 @@ def change_tempo(
     return np.frombuffer(completed.stdout, dtype="<f4").copy()
 
 
+def pcm16_bytes(samples: NDArray[np.floating]) -> bytes:
+    values = np.asarray(samples, dtype=np.float32).reshape(-1)
+    return np.clip(np.rint(values * 32_768), -32_768, 32_767).astype("<i2").tobytes()
+
+
 def _change_pcm_tempo(pcm: bytes, factor: float) -> bytes:
     if factor == 1.0:
         return pcm
     samples = np.frombuffer(pcm, dtype="<i2").astype(np.float32) / 32_768
     changed = change_tempo(samples, PLAYBACK_SAMPLE_RATE, factor)
-    return np.clip(np.rint(changed * 32_768), -32_768, 32_767).astype("<i2").tobytes()
+    return pcm16_bytes(changed)
 
 
 def _tempo_factors(factor: float) -> list[float]:
diff --git a/src/agent_voice/cli.py b/src/agent_voice/cli.py
index 4aa7ce4..acda897 100644
--- a/src/agent_voice/cli.py
+++ b/src/agent_voice/cli.py
@@ -75,16 +75,6 @@ def build_parser() -> argparse.ArgumentParser:
         description="Create a local audio recording from positional text or stdin.",
     )
     speak.add_argument("text", nargs="?", help="text to read; omit to read stdin")
-    response = speak.add_mutually_exclusive_group()
-    response.add_argument(
-        "--markdown",
-        help="Markdown response to show in the browser viewer",
-    )
-    response.add_argument(
-        "--response-file",
-        type=Path,
-        help="Markdown response to show in the browser viewer",
-    )
     speak.add_argument(
         "-o",
         "--output",
@@ -132,6 +122,11 @@ def build_parser() -> argparse.ArgumentParser:
         action="store_true",
         help="include experimental desktop playback control links",
     )
+    speak.add_argument(
+        "--wait",
+        action="store_true",
+        help="wait for the completed recording before returning",
+    )
     _add_model_arguments(speak)
     speak.add_argument(
         "--no-service",
@@ -477,16 +472,10 @@ def _models(args: argparse.Namespace) -> None:
 
 def _speak(args: argparse.Namespace) -> None:
     text = args.text if args.text is not None else sys.stdin.read()
-    response_markdown = (
-        _read_response_file(args.response_file)
-        if args.response_file is not None
-        else args.markdown
-    )
     receipt = Speaker().speak(
         SpeakRequest(
             text=text,
             selection=_model_selection(args),
-            response_markdown=response_markdown,
             output=args.output,
             label=args.label,
             output_dir=args.output_dir,
@@ -498,20 +487,12 @@ def _speak(args: argparse.Namespace) -> None:
             no_service=args.no_service,
             service_url=args.service_url,
             controls=args.controls,
+            wait=args.wait,
         )
     )
     print(json.dumps(receipt.to_dict()))
 
 
-def _read_response_file(path: Path) -> str:
-    try:
-        return path.expanduser().read_text(encoding="utf-8")
-    except FileNotFoundError:
-        raise
-    except (OSError, UnicodeError) as error:
-        raise ValueError(f"Could not read response file: {error}") from error
-
-
 def _config(args: argparse.Namespace) -> None:
     updates: dict[str, object] = {}
     if args.voice is not None:
diff --git a/src/agent_voice/client.py b/src/agent_voice/client.py
index dc3c852..9c2a3b4 100644
--- a/src/agent_voice/client.py
+++ b/src/agent_voice/client.py
@@ -74,6 +74,7 @@ def ensure_service(
     selection: ModelSelection,
     idle_timeout_minutes: float | None,
     startup_timeout: float = 10.0,
+    required_feature: str | None = None,
 ) -> dict[str, object]:
     """Start one detached localhost service and wait until it is healthy."""
     url = validate_service_url(service_url)
@@ -95,7 +96,12 @@ def ensure_service(
             except ServiceUnavailable:
                 pass
             else:
-                return _require_matching_model(health, selection)
+                matched = _require_matching_model(health, selection)
+                if required_feature is None or required_feature in matched.get(
+                    "features", []
+                ):
+                    return matched
+                stop_service(url)
 
             lifecycle = (
                 "no idle timeout"
@@ -147,6 +153,12 @@ def ensure_service(
                         time.sleep(0.05)
                     else:
                         matched = _require_matching_model(health, selection)
+                        if required_feature is not None and required_feature not in (
+                            matched.get("features", [])
+                        ):
+                            raise ServiceUnavailable(
+                                f"service does not support {required_feature}"
+                            )
                         ready = True
                         return matched
                 raise ServiceUnavailable(f"service did not become ready: {last_error}")
@@ -167,7 +179,7 @@ def request_speech(
     lang: str,
     *,
     selection: ModelSelection | None = None,
-    timeout: float = 300,
+    timeout: float = 7_200,
 ) -> Recording:
     if selection is not None:
         _require_matching_model(health_check(service_url), selection)
@@ -180,7 +192,8 @@ def request_speech(
             "lang": lang,
             "response_format": audio_format,
             "play": False,
-        }
+        },
+        ensure_ascii=False,
     ).encode()
     request = urllib.request.Request(
         url,
@@ -218,6 +231,93 @@ def request_speech(
     )
 
 
+def request_speech_background(
+    service_url: str,
+    text: str,
+    destination: Path,
+    audio_format: str,
+    voice: str,
+    speed: float,
+    lang: str,
+    *,
+    selection: ModelSelection,
+    timeout: float = 30,
+) -> Recording:
+    destination = destination.expanduser().resolve()
+    health = _require_matching_model(health_check(service_url), selection)
+    service_root = health.get("recording_root")
+    client_root = str(destination.parent)
+    if service_root != client_root:
+        raise ServiceUnavailable(
+            "localhost recording directory mismatch: "
+            f"client uses {client_root}; service uses {service_root or 'unknown'}. "
+            "Restart the service with the same Agent Voice runtime as the client"
+        )
+    if "streaming" not in health.get("features", []):
+        raise ServiceUnavailable(
+            "running service does not support streaming audio; restart it"
+        )
+    body = json.dumps(
+        {
+            "input": text,
+            "voice": voice,
+            "speed": speed,
+            "lang": lang,
+            "response_format": audio_format,
+            "play": False,
+            "background": {"recording_name": destination.name},
+        },
+        ensure_ascii=False,
+    ).encode()
+    request = urllib.request.Request(
+        validate_service_url(service_url) + "/v1/audio/speech",
+        data=body,
+        headers={"Content-Type": "application/json"},
+        method="POST",
+    )
+    try:
+        with urllib.request.urlopen(request, timeout=timeout) as response:
+            payload = json.loads(response.read())
+            status = response.status
+    except urllib.error.HTTPError as error:
+        detail = _http_error_detail(error)
+        if 400 <= error.code < 500:
+            raise ValueError(
+                f"Agent Voice service rejected the request: {detail}"
+            ) from error
+        raise ServiceUnavailable(f"Agent Voice service failed: {detail}") from error
+    except (
+        OSError,
+        TimeoutError,
+        socket.timeout,
+        urllib.error.URLError,
+        json.JSONDecodeError,
+    ) as error:
+        raise ServiceUnavailable(
+            f"background speech request failed: {error}"
+        ) from error
+    if (
+        status != 202
+        or not isinstance(payload, dict)
+        or payload.get("state") != "started"
+        or payload.get("recording") != destination.name
+        or not destination.is_file()
+    ):
+        raise ServiceUnavailable(
+            "background speech request returned an invalid response"
+        )
+    return Recording(
+        path=destination,
+        format=audio_format,
+        voice=voice,
+        speed=speed,
+        sample_rate=None,
+        duration_seconds=None,
+        generation_seconds=None,
+        backend="service",
+    )
+
+
 def stop_service(service_url: str, timeout: float = 2.0) -> bool:
     url = validate_service_url(service_url)
     try:
diff --git a/src/agent_voice/controls.py b/src/agent_voice/controls.py
index 293857c..6aa1e63 100644
--- a/src/agent_voice/controls.py
+++ b/src/agent_voice/controls.py
@@ -67,6 +67,7 @@ def _install_macos_handler() -> Path:
     with tempfile.TemporaryDirectory(dir=destination.parent) as temporary:
         candidate = Path(temporary) / _APP_NAME
         script = (
+            "property idleTicks : 0\n"
             "on dispatchControl(commandName, controlValue)\n"
             'do shell script "/usr/bin/nohup " & quoted form of '
             f'"{_applescript_string(sys.executable)}" & '
@@ -75,10 +76,16 @@ def _install_macos_handler() -> Path:
             '" >/dev/null 2>&1 &"\n'
             "end dispatchControl\n"
             "on open location theURL\n"
+            "set idleTicks to 0\n"
             'dispatchControl("control-url", theURL)\n'
-            "end open location"
+            "end open location\n"
+            "on idle\n"
+            "set idleTicks to idleTicks + 1\n"
+            "if idleTicks >= 5 then quit\n"
+            "return 1\n"
+            "end idle"
         )
-        _run(["/usr/bin/osacompile", "-o", str(candidate), "-e", script])
+        _run(["/usr/bin/osacompile", "-s", "-o", str(candidate), "-e", script])
         info_path = candidate / "Contents" / "Info.plist"
         with info_path.open("rb") as stream:
             info = plistlib.load(stream)
diff --git a/src/agent_voice/delivery.py b/src/agent_voice/delivery.py
index ccc060b..ec07e14 100644
--- a/src/agent_voice/delivery.py
+++ b/src/agent_voice/delivery.py
@@ -12,6 +12,7 @@
     publish_player,
     publish_source,
     recording_control_urls,
+    recording_stream_url,
     recording_urls,
 )
 
@@ -20,6 +21,7 @@
 class Delivery:
     browser_url: str | None = None
     audio_url: str | None = None
+    stream_url: str | None = None
     recording_path: Path | None = None
     controls: dict[str, str] | None = None
     warning: str | None = None
@@ -29,7 +31,6 @@ def prepare_delivery(
     recording: Path,
     text: str,
     *,
-    source_text: str | None = None,
     language: str = "en-us",
     audio_format: str | None = None,
     recordings_dir: Path | None = None,
@@ -48,14 +49,14 @@ def prepare_delivery(
 
     try:
         published = publish_recording(path, resolved_format, recordings_dir)
-        source = text if source_text is None else source_text
-        publish_source(path, source)
+        publish_source(path, text)
         if published != path:
-            publish_source(published, source)
-        player_name = publish_player(published, text)
+            publish_source(published, text)
+        player_name = publish_player(published)
         publish_language(published, language)
         viewer = ensure_viewer(published.parent)
         browser_url, audio_url = recording_urls(viewer, published, player_name)
+        stream_url = recording_stream_url(viewer, published)
     except (OSError, RuntimeError) as error:
         return Delivery(
             warning=f"Could not start recording viewer; using file fallback ({error})",
@@ -74,6 +75,7 @@ def prepare_delivery(
     return Delivery(
         browser_url=browser_url,
         audio_url=audio_url,
+        stream_url=stream_url,
         recording_path=published,
         controls=control_urls,
         warning=warning,
diff --git a/src/agent_voice/kokoro.py b/src/agent_voice/kokoro.py
index a9686d9..3252c9c 100644
--- a/src/agent_voice/kokoro.py
+++ b/src/agent_voice/kokoro.py
@@ -8,7 +8,7 @@
 import threading
 import time
 import urllib.request
-from collections.abc import Callable
+from collections.abc import Callable, Iterator
 from pathlib import Path
 from typing import Protocol
 
@@ -39,6 +39,9 @@
 KOKORO_DISPLAY_NAME = "Kokoro-82M"
 KOKORO_RUNTIME_NAME = "kokoro-onnx"
 KOKORO_NATURAL_SPEED = 1.0
+KOKORO_MAX_TEXT_CHARACTERS = 50_000
+# Voice styles are indexed by token count, so the 510-row table ends at 509.
+KOKORO_MAX_PHONEMES = 509
 DEFAULT_KOKORO_VARIANT = "int8"
 RELEASE_BASE = (
     "https://github.com/thewh1teagle/kokoro-onnx/releases/download/model-files-v1.0"
@@ -89,6 +92,10 @@ def create(
         self, text: str, *, voice: str, speed: float, lang: str
     ) -> tuple[NDArray[np.floating], int]: ...
 
+    def create_chunks(
+        self, text: str, *, voice: str, speed: float, lang: str
+    ) -> Iterator[tuple[NDArray[np.floating], int]]: ...
+
 
 RuntimeFactory = Callable[[Path, Path], _KokoroRuntime]
 
@@ -196,11 +203,49 @@ def voice_catalog(self) -> VoiceCatalog:
         )
 
     def synthesize(self, request: SynthesisRequest) -> Speech:
+        text, runtime, voice, language = self._prepare_request(request)
+        started = time.perf_counter()
+        with self._inference_lock:
+            samples, sample_rate = runtime.create(
+                text,
+                voice=voice,
+                speed=KOKORO_NATURAL_SPEED,
+                lang=language,
+            )
+        samples = change_tempo(samples, sample_rate, float(request.speed))
+        return Speech(samples, sample_rate, time.perf_counter() - started)
+
+    def synthesize_stream(self, request: SynthesisRequest) -> Iterator[Speech]:
+        text, runtime, voice, language = self._prepare_request(request)
+        with self._inference_lock:
+            chunks = iter(
+                runtime.create_chunks(
+                    text,
+                    voice=voice,
+                    speed=KOKORO_NATURAL_SPEED,
+                    lang=language,
+                )
+            )
+            while True:
+                started = time.perf_counter()
+                try:
+                    samples, sample_rate = next(chunks)
+                except StopIteration:
+                    break
+                samples = change_tempo(samples, sample_rate, float(request.speed))
+                yield Speech(samples, sample_rate, time.perf_counter() - started)
+
+    def _prepare_request(
+        self, request: SynthesisRequest
+    ) -> tuple[str, _KokoroRuntime, str, str]:
         text = request.text.strip()
         if not text:
             raise ValueError("Text cannot be empty")
-        if len(text) > 20_000:
-            raise ValueError("Text is too long (maximum 20,000 characters per request)")
+        if len(text) > KOKORO_MAX_TEXT_CHARACTERS:
+            raise ValueError(
+                "Text is too long "
+                f"(maximum {KOKORO_MAX_TEXT_CHARACTERS:,} characters per request)"
+            )
         if (
             isinstance(request.speed, bool)
             or not isinstance(request.speed, (int, float))
@@ -226,16 +271,7 @@ def synthesize(self, request: SynthesisRequest) -> Speech:
         if voice not in runtime.get_voices():
             raise ValueError(f"Unknown voice '{voice}'")
 
-        started = time.perf_counter()
-        with self._inference_lock:
-            samples, sample_rate = runtime.create(
-                text,
-                voice=voice,
-                speed=KOKORO_NATURAL_SPEED,
-                lang=language,
-            )
-        samples = change_tempo(samples, sample_rate, float(request.speed))
-        return Speech(samples, sample_rate, time.perf_counter() - started)
+        return text, runtime, voice, language
 
     @property
     def variant(self) -> str:
@@ -277,7 +313,41 @@ def _assets_ready(self) -> bool:
 def _load_runtime(model: Path, voices: Path) -> _KokoroRuntime:
     from kokoro_onnx import Kokoro
 
-    return Kokoro(str(model), str(voices))
+    class AgentVoiceKokoro(Kokoro):
+        @staticmethod
+        def _split_phonemes(phonemes: str) -> list[str]:
+            return _split_phonemes(phonemes)
+
+        def create_chunks(self, text: str, *, voice: str, speed: float, lang: str):
+            phonemes = self.tokenizer.phonemize(text, lang)
+            for chunk in _split_phonemes(phonemes):
+                yield self.create(
+                    chunk,
+                    voice=voice,
+                    speed=speed,
+                    lang=lang,
+                    is_phonemes=True,
+                )
+
+    return AgentVoiceKokoro(str(model), str(voices))
+
+
+def _split_phonemes(phonemes: str) -> list[str]:
+    """Keep every phoneme while preferring natural batch boundaries."""
+    chunks: list[str] = []
+    remaining = phonemes.strip()
+    while len(remaining) > KOKORO_MAX_PHONEMES:
+        window = remaining[:KOKORO_MAX_PHONEMES]
+        split_at = max(window.rfind(mark) for mark in ".,!?;:") + 1
+        if split_at <= 1:
+            split_at = window.rfind(" ")
+        if split_at <= 0:
+            split_at = KOKORO_MAX_PHONEMES
+        chunks.append(remaining[:split_at].strip())
+        remaining = remaining[split_at:].strip()
+    if remaining:
+        chunks.append(remaining)
+    return chunks
 
 
 def _valid_asset(path: Path, asset: Asset) -> bool:
diff --git a/src/agent_voice/media.py b/src/agent_voice/media.py
index 9be7c27..462764f 100644
--- a/src/agent_voice/media.py
+++ b/src/agent_voice/media.py
@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+from importlib import resources
+
 
 CONTENT_TYPES = {
     "wav": "audio/wav",
@@ -7,3 +9,11 @@
     "opus": "audio/ogg",
     "m4a": "audio/mp4",
 }
+
+
+def generating_audio(audio_format: str) -> bytes:
+    return (
+        resources.files("agent_voice")
+        .joinpath("resources", f"generating.{audio_format}")
+        .read_bytes()
+    )
diff --git a/src/agent_voice/model.py b/src/agent_voice/model.py
index 1facb81..e45ac3b 100644
--- a/src/agent_voice/model.py
+++ b/src/agent_voice/model.py
@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from collections.abc import Iterator
 from dataclasses import dataclass
 from enum import StrEnum
 from pathlib import Path
@@ -152,3 +153,5 @@ def status(self) -> ModelStatus: ...
     def voice_catalog(self) -> VoiceCatalog: ...
 
     def synthesize(self, request: SynthesisRequest) -> Speech: ...
+
+    def synthesize_stream(self, request: SynthesisRequest) -> Iterator[Speech]: ...
diff --git a/src/agent_voice/paths.py b/src/agent_voice/paths.py
index 85efb12..bd9720b 100644
--- a/src/agent_voice/paths.py
+++ b/src/agent_voice/paths.py
@@ -61,3 +61,16 @@ def model_dir() -> Path:
         if configured
         else project_root() / "models"
     )
+
+
+def pending_generation_path(recording: Path) -> Path:
+    return _generation_path(recording, "pending")
+
+
+def streaming_pcm_path(recording: Path) -> Path:
+    return _generation_path(recording, "pcm")
+
+
+def _generation_path(recording: Path, suffix: str) -> Path:
+    path = recording.expanduser().resolve()
+    return path.with_name(f".{path.name}.{suffix}")
diff --git a/src/agent_voice/resources/generating.m4a b/src/agent_voice/resources/generating.m4a
new file mode 100644
index 0000000..70028a7
Binary files /dev/null and b/src/agent_voice/resources/generating.m4a differ
diff --git a/src/agent_voice/resources/generating.mp3 b/src/agent_voice/resources/generating.mp3
new file mode 100644
index 0000000..0afa56e
Binary files /dev/null and b/src/agent_voice/resources/generating.mp3 differ
diff --git a/src/agent_voice/resources/generating.opus b/src/agent_voice/resources/generating.opus
new file mode 100644
index 0000000..4666465
Binary files /dev/null and b/src/agent_voice/resources/generating.opus differ
diff --git a/src/agent_voice/resources/generating.wav b/src/agent_voice/resources/generating.wav
new file mode 100644
index 0000000..103f03b
Binary files /dev/null and b/src/agent_voice/resources/generating.wav differ
diff --git a/src/agent_voice/service.py b/src/agent_voice/service.py
index 2c33ab7..fe68601 100644
--- a/src/agent_voice/service.py
+++ b/src/agent_voice/service.py
@@ -11,11 +11,24 @@
 from pathlib import Path
 from typing import Any
 
+import numpy as np
+
 from . import __version__
-from .audio import play_audio, write_audio
+from .audio import (
+    PLAYBACK_SAMPLE_RATE,
+    pcm16_bytes,
+    play_audio,
+    write_audio,
+    write_audio_bytes,
+)
 from .config import FORMATS, load_defaults
-from .media import CONTENT_TYPES
-from .model import NamedVoice, SpeechModel, SynthesisRequest
+from .media import CONTENT_TYPES, generating_audio
+from .model import NamedVoice, Speech, SpeechModel, SynthesisRequest
+from .paths import (
+    pending_generation_path,
+    resolved_recording_dir,
+    streaming_pcm_path,
+)
 
 
 @dataclass(frozen=True)
@@ -26,6 +39,13 @@ class SpeechRequest:
     lang: str
     audio_format: str
     play: bool
+    background_recording: str | None = None
+
+
+def _stream_pcm(speech: Speech) -> bytes:
+    if speech.sample_rate != PLAYBACK_SAMPLE_RATE:
+        raise RuntimeError(f"Streaming requires {PLAYBACK_SAMPLE_RATE} Hz audio")
+    return pcm16_bytes(np.asarray(speech.samples, dtype=np.float32).reshape(-1))
 
 
 def validate_payload(payload: object) -> SpeechRequest:
@@ -38,6 +58,7 @@ def validate_payload(payload: object) -> SpeechRequest:
     lang = payload.get("lang", "en-us")
     audio_format = payload.get("response_format", defaults.format)
     play = payload.get("play", False)
+    background = payload.get("background")
     if not isinstance(text, str):
         raise ValueError("input must be a string")
     if not isinstance(voice, str) or not voice:
@@ -50,12 +71,29 @@ def validate_payload(payload: object) -> SpeechRequest:
         raise ValueError(f"response_format must be one of: {', '.join(FORMATS)}")
     if not isinstance(play, bool):
         raise ValueError("play must be a boolean")
-    return SpeechRequest(text, voice, float(speed), lang, audio_format.lower(), play)
+    background_recording = None
+    if background is not None:
+        if not isinstance(background, dict):
+            raise ValueError("background must be an object")
+        background_recording = background.get("recording_name")
+        if not isinstance(background_recording, str) or not background_recording:
+            raise ValueError("background.recording_name must be a non-empty string")
+        if play:
+            raise ValueError("background speech cannot use play")
+    return SpeechRequest(
+        text,
+        voice,
+        float(speed),
+        lang,
+        audio_format.lower(),
+        play,
+        background_recording,
+    )
 
 
 class TTSRequestHandler(BaseHTTPRequestHandler):
     model: SpeechModel
-    max_body_bytes = 100_000
+    max_body_bytes = 1_000_000
     server_version = f"AgentVoice/{__version__}"
 
     def setup(self) -> None:
@@ -86,6 +124,10 @@ def do_GET(self) -> None:
                     "model_id": descriptor.selection.model_id,
                     "variant": descriptor.selection.variant,
                     "ready": True,
+                    "features": ["streaming"],
+                    "recording_root": str(
+                        resolved_recording_dir(load_defaults().output_dir).resolve()
+                    ),
                     "service_timeout_minutes": idle_timeout_minutes,
                 },
             )
@@ -136,29 +178,117 @@ def do_POST(self) -> None:
         try:
             payload = self._read_json()
             request = validate_payload(payload)
-            audio = self._synthesize(request)
         except (ValueError, json.JSONDecodeError) as error:
             self._json(400, {"error": str(error)})
+            return
+        if request.background_recording is not None:
+            try:
+                self._generate_in_background(request)
+            except ValueError as error:
+                self._json(400, {"error": str(error)})
+            except Exception as error:
+                self._json(500, {"error": str(error)})
+            return
+        try:
+            audio = self._synthesize(request)
         except Exception as error:
             self._json(500, {"error": str(error)})
-        else:
-            self.send_response(200)
-            data, audio_format, voice, metadata = audio
-            self.send_header("Content-Type", CONTENT_TYPES[audio_format])
-            self.send_header("Content-Length", str(len(data)))
-            self.send_header("X-Agent-Voice-Voice", voice)
-            self.send_header("X-Agent-Voice-Speed", str(request.speed))
-            self.send_header("X-Agent-Voice-Sample-Rate", str(metadata["sample_rate"]))
-            self.send_header(
-                "X-Agent-Voice-Duration", str(metadata["duration_seconds"])
+            return
+        self.send_response(200)
+        data, audio_format, voice, metadata = audio
+        self.send_header("Content-Type", CONTENT_TYPES[audio_format])
+        self.send_header("Content-Length", str(len(data)))
+        self.send_header("X-Agent-Voice-Voice", voice)
+        self.send_header("X-Agent-Voice-Speed", str(request.speed))
+        self.send_header("X-Agent-Voice-Sample-Rate", str(metadata["sample_rate"]))
+        self.send_header("X-Agent-Voice-Duration", str(metadata["duration_seconds"]))
+        self.send_header(
+            "X-Agent-Voice-Generation-Seconds",
+            str(metadata["generation_seconds"]),
+        )
+        self.send_header("X-Agent-Voice-Played", str(metadata["played"]).lower())
+        self.end_headers()
+        self.wfile.write(data)
+
+    def _generate_in_background(self, request: SpeechRequest) -> None:
+        destination = self._background_destination(
+            request.background_recording, request.audio_format
+        )
+        pending = pending_generation_path(destination)
+        stream_path = streaming_pcm_path(destination)
+        response_started = False
+        started = time.perf_counter()
+        try:
+            pending.touch(mode=0o600, exist_ok=False)
+            stream_path.touch(mode=0o600, exist_ok=False)
+            write_audio_bytes(generating_audio(request.audio_format), destination)
+            synthesis_request = SynthesisRequest(
+                text=request.text,
+                voice=NamedVoice(request.voice),
+                speed=request.speed,
+                language=request.lang,
             )
-            self.send_header(
-                "X-Agent-Voice-Generation-Seconds",
-                str(metadata["generation_seconds"]),
+            with stream_path.open("ab", buffering=0) as stream:
+                chunks = iter(self.model.synthesize_stream(synthesis_request))
+                for speech in chunks:
+                    chunk = _stream_pcm(speech)
+                    if not chunk:
+                        continue
+                    stream.write(chunk)
+                    break
+                else:
+                    raise RuntimeError("Speech generation returned no audio")
+                self._json(202, {"state": "started", "recording": destination.name})
+                response_started = True
+                for speech in chunks:
+                    chunk = _stream_pcm(speech)
+                    if chunk:
+                        stream.write(chunk)
+            samples = np.fromfile(stream_path, dtype="<i2").astype(np.float32)
+            samples /= 32_768
+            write_audio(
+                samples,
+                PLAYBACK_SAMPLE_RATE,
+                destination,
+                request.audio_format,
             )
-            self.send_header("X-Agent-Voice-Played", str(metadata["played"]).lower())
-            self.end_headers()
-            self.wfile.write(data)
+            self.log_message(
+                "background speech completed in %.3fs", time.perf_counter() - started
+            )
+        except Exception as error:
+            destination.unlink(missing_ok=True)
+            stream_path.unlink(missing_ok=True)
+            if response_started:
+                self.log_error("background speech failed: %s", error)
+            else:
+                raise
+        finally:
+            pending.unlink(missing_ok=True)
+
+    def _background_destination(
+        self, recording_name: str | None, audio_format: str
+    ) -> Path:
+        if recording_name is None:
+            raise ValueError("background recording name is missing")
+        name = Path(recording_name)
+        root = resolved_recording_dir(load_defaults().output_dir).resolve()
+        destination = (root / name).resolve()
+        if (
+            name.name != recording_name
+            or destination.parent != root
+            or destination.suffix.lower() != f".{audio_format}"
+        ):
+            raise ValueError(
+                "background recording name must be a managed filename matching "
+                "response_format"
+            )
+        if (
+            not destination.is_file()
+            or destination.is_symlink()
+            or destination.stat().st_size != 0
+        ):
+            raise ValueError("background recording must be a new managed reservation")
+        return destination
 
     def _synthesize(
         self, request: SpeechRequest
@@ -196,7 +326,9 @@ def _read_json(self) -> dict[str, Any]:
             raise ValueError("Content-Type must be application/json")
         length = int(self.headers.get("Content-Length", "0"))
         if length <= 0 or length > self.max_body_bytes:
-            raise ValueError("Request body must be between 1 and 100,000 bytes")
+            raise ValueError(
+                f"Request body must be between 1 and {self.max_body_bytes:,} bytes"
+            )
         payload = json.loads(self.rfile.read(length))
         if not isinstance(payload, dict):
             raise ValueError("JSON body must be an object")
@@ -326,6 +458,41 @@ def create_server(
     return IdleHTTPServer((host, port), handler, idle_timeout_seconds)
 
 
+def _recover_interrupted_generations() -> int:
+    root = resolved_recording_dir(load_defaults().output_dir).resolve()
+    if not root.is_dir():
+        return 0
+    recovered = 0
+    # ponytail: one service owns a managed recording root; add per-job locks if
+    # multi-port services ever need to share one root.
+    for pending in root.glob(".*.pending"):
+        recording = root / pending.name[1 : -len(".pending")]
+        audio_format = recording.suffix.lower().lstrip(".")
+        if audio_format not in FORMATS:
+            continue
+        try:
+            placeholder = generating_audio(audio_format)
+            remove_recording = (
+                recording.is_file()
+                and not recording.is_symlink()
+                and (
+                    recording.stat().st_size == 0
+                    or (
+                        recording.stat().st_size == len(placeholder)
+                        and recording.read_bytes() == placeholder
+                    )
+                )
+            )
+            if remove_recording:
+                recording.unlink()
+            streaming_pcm_path(recording).unlink(missing_ok=True)
+            pending.unlink()
+        except OSError:
+            continue
+        recovered += 1
+    return recovered
+
+
 def serve(
     model: SpeechModel,
     host: str,
@@ -333,7 +500,10 @@ def serve(
     idle_timeout_seconds: float | None = None,
 ) -> None:
     server = create_server(model, host, port, idle_timeout_seconds)
+    recovered = _recover_interrupted_generations()
     print(f"Agent Voice listening on http://{host}:{server.server_port}")
+    if recovered:
+        print(f"Recovered {recovered} interrupted generation(s)")
     if idle_timeout_seconds is not None:
         print(f"Stops after {idle_timeout_seconds / 60:g} idle minutes")
     print("POST /v1/audio/speech · GET /voices · GET /health")
diff --git a/src/agent_voice/speaking.py b/src/agent_voice/speaking.py
index ec3cad9..c535112 100644
--- a/src/agent_voice/speaking.py
+++ b/src/agent_voice/speaking.py
@@ -15,6 +15,7 @@
     ServiceUnavailable,
     ensure_service,
     request_speech,
+    request_speech_background,
 )
 from .config import FORMATS, SpeechDefaults, load_defaults
 from .delivery import Delivery, prepare_delivery
@@ -44,8 +45,8 @@ class SpeakRequest:
     play_after: float | None = None
     no_service: bool = False
     service_url: str = DEFAULT_SERVICE_URL
-    response_markdown: str | None = None
     controls: bool = False
+    wait: bool = False
 
 
 @dataclass(frozen=True)
@@ -55,6 +56,7 @@ class SpeakReceipt:
     delivery: Delivery
     playback: dict[str, object] | None = None
     service_fallback: bool = False
+    generation: dict[str, object] | None = None
 
     def to_dict(self) -> dict[str, object]:
         payload = self.recording.to_dict()
@@ -64,16 +66,22 @@ def to_dict(self) -> dict[str, object]:
             payload["playback"] = self.playback
         if self.service_fallback:
             payload["service_fallback"] = True
+        if self.generation is not None:
+            payload["generation"] = self.generation
         payload["file_uri"] = self.recording.path.resolve().as_uri()
         delivery: dict[str, object] = {}
         if self.delivery.browser_url is not None:
-            delivery.update(
-                {
-                    "browser_url": self.delivery.browser_url,
-                    "audio_url": self.delivery.audio_url,
-                    "recording_path": str(self.delivery.recording_path),
-                }
-            )
+            delivery["browser_url"] = self.delivery.browser_url
+            if self.generation is not None:
+                if self.delivery.stream_url is not None:
+                    delivery["stream_url"] = self.delivery.stream_url
+            else:
+                delivery.update(
+                    {
+                        "audio_url": self.delivery.audio_url,
+                        "recording_path": str(self.delivery.recording_path),
+                    }
+                )
             if self.delivery.controls is not None:
                 delivery["controls"] = self.delivery.controls
         payload["delivery"] = delivery
@@ -91,7 +99,6 @@ class _OutputPlan:
 @dataclass(frozen=True)
 class _ResolvedSpeakRequest:
     text: str
-    response_markdown: str
     selection: ModelSelection
     output: _OutputPlan
     voice: str
@@ -102,19 +109,23 @@ class _ResolvedSpeakRequest:
     service_timeout_minutes: float
     service_url: str
     controls: bool
+    wait: bool
 
 
 class _RecordingGenerator(Protocol):
     def generate(self, request: _ResolvedSpeakRequest) -> Recording: ...
 
 
+class _ServiceRecordingGenerator(_RecordingGenerator, Protocol):
+    def generate_background(self, request: _ResolvedSpeakRequest) -> Recording: ...
+
+
 class _DeliveryPreparer(Protocol):
     def __call__(
         self,
         recording: Path,
         text: str,
         *,
-        source_text: str,
         language: str,
         audio_format: str,
         recordings_dir: Path,
@@ -174,6 +185,24 @@ def generate(self, request: _ResolvedSpeakRequest) -> Recording:
             selection=request.selection,
         )
 
+    def generate_background(self, request: _ResolvedSpeakRequest) -> Recording:
+        ensure_service(
+            request.service_url,
+            request.selection,
+            request.service_timeout_minutes,
+            required_feature="streaming",
+        )
+        return request_speech_background(
+            request.service_url,
+            request.text,
+            request.output.destination,
+            request.output.audio_format,
+            request.voice,
+            request.speed,
+            request.language,
+            selection=request.selection,
+        )
+
 
 class Speaker:
     """Resolve and execute one complete speaking request."""
@@ -183,7 +212,7 @@ def __init__(
         *,
         defaults_loader: Callable[[], SpeechDefaults] = load_defaults,
         embedded: _RecordingGenerator | None = None,
-        service: _RecordingGenerator | None = None,
+        service: _ServiceRecordingGenerator | None = None,
         playback: Callable[[Path, float | None], dict[str, object]] = (
             lambda path, delay: start_playback(path, after=delay)
         ),
@@ -207,8 +236,20 @@ def speak(self, request: SpeakRequest) -> SpeakReceipt:
         defaults = self._defaults_loader()
         resolved = self._resolve(request, defaults)
         fallback = False
+        background = _background_generation(resolved)
         try:
-            if resolved.no_service:
+            if background:
+                try:
+                    recording = self._service.generate_background(resolved)
+                except ServiceUnavailable as error:
+                    fallback = True
+                    background = False
+                    self._notice(
+                        "Agent Voice streaming unavailable; using embedded inference "
+                        f"({error})"
+                    )
+                    recording = self._embedded.generate(resolved)
+            elif resolved.no_service:
                 recording = self._embedded.generate(resolved)
             else:
                 try:
@@ -228,8 +269,7 @@ def speak(self, request: SpeakRequest) -> SpeakReceipt:
 
         delivery = self._delivery(
             recording.path,
-            resolved.response_markdown,
-            source_text=resolved.text,
+            resolved.text,
             language=resolved.language,
             audio_format=recording.format,
             recordings_dir=resolved.output.recording_root,
@@ -250,6 +290,7 @@ def speak(self, request: SpeakRequest) -> SpeakReceipt:
             delivery=delivery,
             playback=playback,
             service_fallback=fallback,
+            generation={"state": "started"} if background else None,
         )
 
     def _resolve(
@@ -259,11 +300,6 @@ def _resolve(
     ) -> _ResolvedSpeakRequest:
         return _ResolvedSpeakRequest(
             text=request.text,
-            response_markdown=(
-                request.text
-                if request.response_markdown is None
-                else request.response_markdown
-            ),
             selection=request.selection,
             output=self._plan_output(request, defaults),
             voice=request.voice if request.voice is not None else defaults.voice,
@@ -274,6 +310,7 @@ def _resolve(
             service_timeout_minutes=defaults.service_timeout_minutes,
             service_url=request.service_url,
             controls=request.controls,
+            wait=request.wait,
         )
 
     def _plan_output(
@@ -338,6 +375,16 @@ def _require_planned_recording(
         raise RuntimeError("Speech backend returned an unexpected recording format")
 
 
+def _background_generation(request: _ResolvedSpeakRequest) -> bool:
+    return (
+        not request.wait
+        and request.output.reserved
+        and request.output.destination.parent == request.output.recording_root
+        and request.play_after is None
+        and not request.no_service
+    )
+
+
 def _filename_label(value: str) -> str:
     label = re.sub(r"[^A-Za-z0-9]+", "-", value).strip("-")
     label = label[:48].rstrip("-")
diff --git a/src/agent_voice/templates/recording.html b/src/agent_voice/templates/recording.html
index 9f20e63..48c6d03 100644
--- a/src/agent_voice/templates/recording.html
+++ b/src/agent_voice/templates/recording.html
@@ -7,30 +7,21 @@
     http-equiv="Content-Security-Policy"
     content="default-src 'none'; img-src data:; media-src 'self'; style-src 'unsafe-inline'"
   >
-  <link
-    rel="icon"
-    type="image/svg+xml"
-    sizes="any"
-    href="$BRAND_ICON"
-  >
+  <link rel="icon" type="image/svg+xml" sizes="any" href="$BRAND_ICON">
   <title>$PAGE_TITLE</title>
   <style>
     :root {
       color-scheme: light dark;
       --background: #fffaf7;
       --foreground: #211c1a;
-      --muted: #635752;
+      --muted: #746761;
       --surface: #f2ebe7;
       --border: #d8cec8;
-      --quote: #c8b8af;
-      --link: #1d4ed8;
       font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
       background: var(--background);
       color: var(--foreground);
     }
 
-    $PYGMENTS_LIGHT
-
     @media (prefers-color-scheme: dark) {
       :root {
         --background: #171311;
@@ -38,213 +29,99 @@
         --muted: #b9aaa2;
         --surface: #26201d;
         --border: #493d37;
-        --quote: #6b554b;
-        --link: #8ab4ff;
       }
-
-      $PYGMENTS_DARK
     }
 
-    * {
-      box-sizing: border-box;
-    }
+    * { box-sizing: border-box; }
 
     body {
       margin: 0;
-      padding: 2rem 1rem;
+      padding: 1.5rem 1rem;
       background: var(--background);
     }
 
     main {
-      width: min(100%, 48rem);
+      width: min(100%, 32rem);
       margin: 0 auto;
     }
 
-    h1 {
-      margin: 0 0 1rem;
-      font-size: clamp(1.25rem, 3vw, 1.5rem);
-      overflow-wrap: anywhere;
-    }
-
-    h2 {
-      margin: 2rem 0 0.75rem;
-      font-size: 0.875rem;
-      letter-spacing: 0.08em;
-      text-transform: uppercase;
-    }
-
-    .recording {
+    header {
       display: flex;
       align-items: center;
-      gap: 0.75rem;
-    }
-
-    .recording-icon {
-      flex: 0 0 auto;
-      width: 4rem;
-      height: 4rem;
-      object-fit: contain;
-    }
-
-    audio {
-      display: block;
-      min-width: 0;
-      width: 100%;
+      gap: 0.625rem;
+      margin-bottom: 1rem;
     }
 
-    section {
-      margin-top: 2rem;
+    header img {
+      width: 2.5rem;
+      height: 2.5rem;
     }
 
-    .response {
-      overflow-wrap: anywhere;
-      line-height: 1.6;
-    }
-
-    .response > :first-child {
-      margin-top: 0;
-    }
-
-    .response > :last-child {
-      margin-bottom: 0;
-    }
-
-    .response h1,
-    .response h2,
-    .response h3 {
-      margin: 1.5rem 0 0.5rem;
-      letter-spacing: normal;
-      text-transform: none;
-    }
-
-    .response h1 {
-      font-size: 1.5rem;
-    }
-
-    .response h2 {
-      font-size: 1.25rem;
-    }
-
-    .response h3 {
-      font-size: 1.1rem;
-    }
-
-    .response a {
-      color: var(--link);
-      text-underline-offset: 0.15em;
+    h1 {
+      margin: 0;
+      font-size: 1.125rem;
     }
 
-    .response blockquote {
-      margin: 1rem 0;
-      padding: 0.1rem 1rem;
-      border-left: 0.25rem solid var(--quote);
+    header p {
+      margin: 0.125rem 0 0;
       color: var(--muted);
+      font-size: 0.8125rem;
+      overflow-wrap: anywhere;
     }
 
-    .response ul,
-    .response ol {
-      padding-left: 1.5rem;
-    }
-
-    .response li + li {
-      margin-top: 0.25rem;
-    }
-
-    .response .contains-task-list,
-    .response .task-list-item {
-      list-style: none;
-    }
-
-    .response .contains-task-list {
-      padding-left: 0;
-    }
-
-    .response .task-list-item-checkbox {
-      margin: 0 0.5rem 0 0;
-      accent-color: var(--link);
-    }
-
-    .response pre {
-      overflow-x: auto;
-      padding: 0.75rem;
-      border: 1px solid var(--border);
-      background: var(--surface);
-      border-radius: 0.5rem;
-    }
-
-    .response code {
-      font-family: ui-monospace, SFMono-Regular, Consolas, monospace;
-    }
-
-    .response :not(pre) > code {
-      padding: 0.1em 0.3em;
-      background: var(--surface);
-      border-radius: 0.25rem;
-      font-size: 0.9em;
-    }
-
-    .response table {
+    audio {
       display: block;
-      max-width: 100%;
-      overflow-x: auto;
-      border-collapse: collapse;
-    }
-
-    .response thead {
-      background: var(--surface);
+      width: 100%;
     }
 
-    .response th,
-    .response td {
-      padding: 0.4rem 0.6rem;
-      border: 1px solid var(--border);
-      text-align: left;
+    .hint {
+      margin: 0.75rem 0 0;
+      color: var(--muted);
+      font-size: 0.875rem;
+      line-height: 1.4;
     }
 
-    .response hr {
-      border: 0;
+    details {
+      margin-top: 1rem;
       border-top: 1px solid var(--border);
+      padding-top: 0.875rem;
     }
 
-    .response img {
-      max-width: 100%;
-      height: auto;
+    summary {
+      cursor: pointer;
+      font-weight: 650;
+      font-size: 0.875rem;
     }
 
-    .response .markdown-alert {
-      margin: 1rem 0;
-      padding: 0.25rem 1rem;
-      border-left: 0.25rem solid var(--link);
+    .narration {
+      margin: 0.75rem 0 0;
+      padding: 0.875rem;
+      border-radius: 0.5rem;
       background: var(--surface);
-    }
-
-    .response .markdown-alert-title {
-      margin-bottom: 0;
-      color: var(--foreground);
-      font-weight: 700;
+      line-height: 1.55;
+      white-space: pre-wrap;
+      overflow-wrap: anywhere;
     }
   </style>
 </head>
 <body>
   <main>
-    <h1>$RECORDING_NAME</h1>
-    <div class="recording">
-      <audio controls preload="metadata">
-        <source src="$MEDIA_SOURCE" type="$MEDIA_TYPE">
-        <a href="$MEDIA_SOURCE">Open the recording</a>
-      </audio>
-      <img
-        class="recording-icon"
-        src="$BRAND_ICON"
-        alt=""
-        width="128"
-        height="128"
-        aria-hidden="true"
-      >
-    </div>
-    <section>
-      <div class="response">$RESPONSE_TEXT</div>
-    </section>
+    <header>
+      <img src="$BRAND_ICON" alt="" width="128" height="128" aria-hidden="true">
+      <div>
+        <h1>Agent Voice</h1>
+        <p>$RECORDING_NAME</p>
+      </div>
+    </header>
+    <audio controls preload="metadata">
+      <source src="$MEDIA_SOURCE" type="$MEDIA_TYPE">
+      <a href="$MEDIA_SOURCE">Open the recording</a>
+    </audio>
+    <p class="hint">Listen here. Read the full response in your conversation.</p>
+    <details>
+      <summary>Narration text</summary>
+      <p class="narration">$RESPONSE_TEXT</p>
+    </details>
   </main>
 </body>
 </html>
diff --git a/src/agent_voice/viewer.py b/src/agent_voice/viewer.py
index 694d5fe..215d59d 100644
--- a/src/agent_voice/viewer.py
+++ b/src/agent_voice/viewer.py
@@ -20,17 +20,24 @@
 from filelock import FileLock
 
 from .audio import PLAYBACK_ACTIONS
-from .media import CONTENT_TYPES
-from .paths import project_root, recording_dir
+from .media import CONTENT_TYPES, generating_audio
+from .paths import (
+    pending_generation_path,
+    project_root,
+    recording_dir,
+    streaming_pcm_path,
+)
 
 
-_TRANSCRIPT_DIRECTORY = ".agent-voice-viewer"
+_VIEWER_DIRECTORY = ".agent-voice-viewer"
 _PLAYER_DIRECTORY = "players"
 _CONTROL_DIRECTORY = "controls"
 _RECORDING_RETENTION_SECONDS = (4 * 24 + 18) * 60 * 60
+_STREAM_RETENTION_SECONDS = 60 * 60
+_INTERRUPTED_GENERATION_RETENTION_SECONDS = 6 * 60 * 60
 _STARTUP_TIMEOUT_SECONDS = 15.0
 _STARTUP_HEALTH_TIMEOUT_SECONDS = 1.0
-VIEWER_PROTOCOL = 9
+VIEWER_PROTOCOL = 12
 _CONTROL_TOKEN = re.compile(r"[A-Za-z0-9_-]{24}")
 
 
@@ -171,10 +178,6 @@ def publish_recording(
     return destination
 
 
-def publish_transcript(recording: Path, text: str) -> Path:
-    return _write_text(transcript_path(recording), text)
-
-
 def publish_source(recording: Path, text: str) -> Path:
     return _write_text(source_path(recording), text)
 
@@ -202,9 +205,8 @@ def _write_text(destination: Path, text: str) -> Path:
     return destination
 
 
-def publish_player(recording: Path, text: str) -> str:
-    publish_transcript(recording, text)
-    root = transcript_path(recording).parent / _PLAYER_DIRECTORY
+def publish_player(recording: Path) -> str:
+    root = _viewer_root(recording) / _PLAYER_DIRECTORY
     root.mkdir(parents=True, exist_ok=True, mode=0o700)
     base = recording.stem
     name = base
@@ -234,17 +236,16 @@ def publish_player(recording: Path, text: str) -> str:
 
 
 def publish_control(recording: Path) -> str:
-    root = transcript_path(recording).parent / _CONTROL_DIRECTORY
+    root = _viewer_root(recording) / _CONTROL_DIRECTORY
     root.mkdir(parents=True, exist_ok=True, mode=0o700)
     token = secrets.token_urlsafe(18)
     _write_text(root / f"{token}.txt", recording.name)
     return token
 
 
-def transcript_path(recording: Path) -> Path:
+def _viewer_root(recording: Path) -> Path:
     path = recording.expanduser().resolve()
-    digest = hashlib.sha256(path.name.encode()).hexdigest()
-    return path.parent / _TRANSCRIPT_DIRECTORY / f"{digest}.txt"
+    return path.parent / _VIEWER_DIRECTORY
 
 
 def source_path(recording: Path) -> Path:
@@ -253,23 +254,48 @@ def source_path(recording: Path) -> Path:
 
 
 def language_path(recording: Path) -> Path:
-    return transcript_path(recording).with_suffix(".lang")
+    path = recording.expanduser().resolve()
+    digest = hashlib.sha256(path.name.encode()).hexdigest()
+    return _viewer_root(path) / f"{digest}.lang"
 
 
 def delete_expired_recordings(recordings: Path, *, now: float | None = None) -> None:
-    cutoff = (time.time() if now is None else now) - _RECORDING_RETENTION_SECONDS
+    current = time.time() if now is None else now
+    cutoff = current - _RECORDING_RETENTION_SECONDS
+    stream_cutoff = current - _STREAM_RETENTION_SECONDS
+    interrupted_cutoff = current - _INTERRUPTED_GENERATION_RETENTION_SECONDS
     try:
         # ponytail: a direct top-level scan is enough for the managed folder.
         for path in recordings.iterdir():
             try:
+                if path.name.startswith(".") and path.suffix == ".pending":
+                    recording = recordings / path.name[1 : -len(path.suffix)]
+                    if path.stat().st_mtime <= interrupted_cutoff:
+                        path.unlink()
+                        streaming_pcm_path(recording).unlink(missing_ok=True)
+                        if recording.is_file() and (
+                            recording.stat().st_size == 0
+                            or recording.read_bytes()
+                            == generating_audio(recording.suffix.lstrip(".").lower())
+                        ):
+                            recording.unlink()
+                    continue
+                if path.name.startswith(".") and path.suffix == ".pcm":
+                    recording = recordings / path.name[1 : -len(path.suffix)]
+                    if (
+                        path.stat().st_mtime <= stream_cutoff
+                        and not pending_generation_path(recording).is_file()
+                    ):
+                        path.unlink()
+                    continue
                 if (
                     path.suffix.lower().lstrip(".") in CONTENT_TYPES
                     and source_path(path).is_file()
-                    and transcript_path(path).is_file()
                     and language_path(path).is_file()
                     and path.stat().st_mtime <= cutoff
                 ):
                     path.unlink()
+                    streaming_pcm_path(path).unlink(missing_ok=True)
             except OSError:
                 continue
     except OSError:
@@ -277,11 +303,20 @@ def delete_expired_recordings(recordings: Path, *, now: float | None = None) ->
 
 
 def player_mapping_path(recordings: Path, player_name: str) -> Path:
-    return recordings / _TRANSCRIPT_DIRECTORY / _PLAYER_DIRECTORY / f"{player_name}.txt"
+    return recordings / _VIEWER_DIRECTORY / _PLAYER_DIRECTORY / f"{player_name}.txt"
 
 
 def control_mapping_path(recordings: Path, token: str) -> Path:
-    return recordings / _TRANSCRIPT_DIRECTORY / _CONTROL_DIRECTORY / f"{token}.txt"
+    return recordings / _VIEWER_DIRECTORY / _CONTROL_DIRECTORY / f"{token}.txt"
+
+
+def recording_player_url(
+    viewer: Viewer,
+    player_name: str,
+) -> str:
+    if not viewer.url:
+        raise RuntimeError("Recording viewer is not running")
+    return f"{viewer.url}/player/{quote(player_name, safe='')}"
 
 
 def recording_urls(
@@ -291,13 +326,18 @@ def recording_urls(
 ) -> tuple[str, str]:
     if not viewer.url:
         raise RuntimeError("Recording viewer is not running")
-    name = quote(recording.name, safe="")
     return (
-        f"{viewer.url}/player/{quote(player_name, safe='')}",
-        f"{viewer.url}/recordings/{name}",
+        recording_player_url(viewer, player_name),
+        f"{viewer.url}/recordings/{quote(recording.name, safe='')}",
     )
 
 
+def recording_stream_url(viewer: Viewer, recording: Path) -> str:
+    if not viewer.url:
+        raise RuntimeError("Recording viewer is not running")
+    return f"{viewer.url}/stream/{quote(recording.name, safe='')}"
+
+
 def recording_control_urls(token: str) -> dict[str, str]:
     if _CONTROL_TOKEN.fullmatch(token) is None:
         raise ValueError("Invalid playback control token")
diff --git a/src/agent_voice/viewer_server.py b/src/agent_voice/viewer_server.py
index 8d83719..a83af13 100644
--- a/src/agent_voice/viewer_server.py
+++ b/src/agent_voice/viewer_server.py
@@ -7,6 +7,7 @@
 import json
 import math
 import os
+import struct
 import threading
 import time
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
@@ -16,17 +17,12 @@
 from string import Template
 from urllib.parse import parse_qs, quote, unquote, urlsplit
 
-from markdown_it import MarkdownIt
-from pygments import highlight
-from pygments.formatters import HtmlFormatter
-from pygments.lexers import get_lexer_by_name
-from pygments.util import ClassNotFound
-
 from . import __version__
 from .audio import PLAYBACK_ACTIONS, PlaybackController, write_audio
 from .config import load_defaults
 from .media import CONTENT_TYPES
 from .model import NamedVoice, SynthesisRequest
+from .paths import pending_generation_path, streaming_pcm_path
 from .registry import MODEL_REGISTRY
 from .viewer import (
     control_mapping_path,
@@ -34,43 +30,13 @@
     language_path,
     player_mapping_path,
     source_path,
-    transcript_path,
     valid_control_token,
     VIEWER_PROTOCOL,
 )
 
 
 DEFAULT_VIEWER_PORT = 8779
-_CLEANUP_INTERVAL_SECONDS = 6 * 60 * 60
-
-
-def _syntax_css(style: str) -> str:
-    return "\n".join(
-        line
-        for line in HtmlFormatter(style=style)
-        .get_style_defs(".response pre code")
-        .splitlines()
-        if line.startswith(".response pre code .")
-    )
-
-
-_CODE_FORMATTER = HtmlFormatter(nowrap=True)
-_PYGMENTS_LIGHT_CSS = _syntax_css("friendly")
-_PYGMENTS_DARK_CSS = _syntax_css("github-dark")
-
-
-def _highlight_code(source: str, language: str, _attrs: str) -> str:
-    try:
-        lexer = get_lexer_by_name(language)
-    except ClassNotFound:
-        return ""
-    return highlight(source, lexer, _CODE_FORMATTER)
-
-
-_MARKDOWN = MarkdownIt(
-    "gfm-like2",
-    {"breaks": True, "highlight": _highlight_code, "html": False},
-)
+_CLEANUP_INTERVAL_SECONDS = 60 * 60
 
 
 class Server(ThreadingHTTPServer):
@@ -216,12 +182,32 @@ def _get(self, *, head: bool) -> None:
         prefix = next(
             (
                 value
-                for value in ("/recordings/", "/player/")
+                for value in ("/recordings/", "/player/", "/stream/")
                 if url.path.startswith(value)
             ),
             None,
         )
         encoded = url.path.removeprefix(prefix or "")
+        if prefix == "/stream/":
+            recording = self._stream_recording(encoded, server)
+            if recording is None:
+                self.send_error(404)
+            elif pending_generation_path(recording).is_file():
+                if streaming_pcm_path(recording).is_file():
+                    self._send_pcm_stream(recording, head)
+                else:
+                    self.send_error(425, "Recording stream is not ready")
+            else:
+                try:
+                    completed = self._recording(encoded, server)
+                except Exception:
+                    self.send_error(503, "Recording regeneration failed")
+                    return
+                if completed is None:
+                    self.send_error(404)
+                else:
+                    self._send_recording_file(completed, encoded, server, head)
+            return
         try:
             recording = (
                 self._player_recording(encoded, server)
@@ -235,18 +221,28 @@ def _get(self, *, head: bool) -> None:
             self.send_error(404)
         elif prefix == "/player/":
             self._send(_player(recording), "text/html; charset=utf-8", head)
+        elif pending_generation_path(recording).is_file():
+            self.send_error(425, "Recording is still being generated")
         else:
-            content_type = CONTENT_TYPES[recording.suffix.lower().lstrip(".")]
-            if not self._send_file(recording, content_type, head):
-                try:
-                    recording = self._recording(encoded, server)
-                except Exception:
-                    self.send_error(503, "Recording regeneration failed")
-                    return
-                if recording is None or not self._send_file(
-                    recording, content_type, head
-                ):
-                    self.send_error(404)
+            self._send_recording_file(recording, encoded, server, head)
+
+    def _send_recording_file(
+        self,
+        recording: Path,
+        encoded: str,
+        server: Server,
+        head: bool,
+    ) -> None:
+        content_type = CONTENT_TYPES[recording.suffix.lower().lstrip(".")]
+        if self._send_file(recording, content_type, head):
+            return
+        try:
+            recording = self._recording(encoded, server)
+        except Exception:
+            self.send_error(503, "Recording regeneration failed")
+            return
+        if recording is None or not self._send_file(recording, content_type, head):
+            self.send_error(404)
 
     def _player_recording(self, encoded: str, server: Server) -> Path | None:
         try:
@@ -272,6 +268,14 @@ def _player_recording(self, encoded: str, server: Server) -> Path | None:
             return None
         return self._recording(quote(recording_name, safe=""), server)
 
+    def _stream_recording(self, encoded: str, server: Server) -> Path | None:
+        try:
+            name = unquote(encoded, errors="strict")
+        except (UnicodeError, ValueError):
+            return None
+        recording = self._recording_path(name, server)
+        return recording
+
     def _control_target(self, path: str, server: Server) -> tuple[Path, str] | None:
         if not path.startswith("/control/"):
             return None
@@ -307,6 +311,8 @@ def _recording(self, encoded: str, server: Server) -> Path | None:
         path = self._recording_path(name, server)
         if path is None:
             return None
+        if pending_generation_path(path).is_file():
+            return path if path.is_file() else None
         if not path.is_file():
             with server.regeneration_lock:
                 if not path.is_file():
@@ -314,7 +320,6 @@ def _recording(self, encoded: str, server: Server) -> Path | None:
                         metadata.is_file()
                         for metadata in (
                             source_path(path),
-                            transcript_path(path),
                             language_path(path),
                         )
                     ):
@@ -322,6 +327,36 @@ def _recording(self, encoded: str, server: Server) -> Path | None:
                     _regenerate_recording(path)
         return path if path.is_file() else None
 
+    def _send_pcm_stream(self, recording: Path, head: bool) -> None:
+        self.send_response(200)
+        self.send_header("Content-Type", "audio/wav")
+        self.send_header("Cache-Control", "private, no-store")
+        self.send_header("X-Content-Type-Options", "nosniff")
+        self.send_header("Connection", "close")
+        self.end_headers()
+        if head:
+            return
+
+        stream_path = streaming_pcm_path(recording)
+        pending = pending_generation_path(recording)
+        try:
+            self.wfile.write(_streaming_wav_header())
+            offset = 0
+            while True:
+                with stream_path.open("rb") as stream:
+                    stream.seek(offset)
+                    chunk = stream.read(64 * 1024)
+                if chunk:
+                    offset += len(chunk)
+                    self.wfile.write(chunk)
+                    self.wfile.flush()
+                elif pending.is_file():
+                    time.sleep(0.05)
+                else:
+                    return
+        except OSError:
+            return
+
     def _recording_path(self, name: str, server: Server) -> Path | None:
         try:
             if (
@@ -488,7 +523,7 @@ def _playback_delay(query: str) -> float | None:
 def _player(recording: Path) -> bytes:
     name = recording.name
     try:
-        response_text = transcript_path(recording).read_text(encoding="utf-8")
+        response_text = source_path(recording).read_text(encoding="utf-8")
     except (OSError, UnicodeError):
         response_text = ""
     template = Template(
@@ -496,18 +531,36 @@ def _player(recording: Path) -> bytes:
         .joinpath("templates", "recording.html")
         .read_text(encoding="utf-8")
     )
+    streaming = pending_generation_path(recording).is_file()
     return template.substitute(
         BRAND_ICON=_image_data_url("brand-icon.svg"),
         PAGE_TITLE=html.escape(f"{name} · Agent Voice", quote=True),
-        PYGMENTS_DARK=_PYGMENTS_DARK_CSS,
-        PYGMENTS_LIGHT=_PYGMENTS_LIGHT_CSS,
         RECORDING_NAME=html.escape(name, quote=True),
-        MEDIA_SOURCE=f"/recordings/{quote(name, safe='')}",
-        MEDIA_TYPE=CONTENT_TYPES[recording.suffix.lower().lstrip(".")],
-        RESPONSE_TEXT=_MARKDOWN.render(response_text),
+        MEDIA_SOURCE=(
+            f"/stream/{quote(name, safe='')}"
+            if streaming
+            else f"/recordings/{quote(name, safe='')}"
+        ),
+        MEDIA_TYPE=(
+            "audio/wav"
+            if streaming
+            else CONTENT_TYPES[recording.suffix.lower().lstrip(".")]
+        ),
+        RESPONSE_TEXT=html.escape(response_text),
     ).encode()
 
 
+def _streaming_wav_header() -> bytes:
+    return (
+        b"RIFF"
+        + struct.pack("<I", 0xFFFFFFFF)
+        + b"WAVEfmt "
+        + struct.pack("<IHHIIHH", 16, 1, 1, 24_000, 48_000, 2, 16)
+        + b"data"
+        + struct.pack("<I", 0xFFFFFFFF)
+    )
+
+
 def _regenerate_recording(recording: Path) -> None:
     text = source_path(recording).read_text(encoding="utf-8")
     language = language_path(recording).read_text(encoding="utf-8").strip()
diff --git a/tests/test_audio.py b/tests/test_audio.py
index db50b70..de4fe8a 100644
--- a/tests/test_audio.py
+++ b/tests/test_audio.py
@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+import threading
+import time
 import wave
 from types import SimpleNamespace
 
@@ -14,6 +16,7 @@
     write_audio,
     write_audio_bytes,
 )
+from agent_voice.paths import pending_generation_path, streaming_pcm_path
 
 
 def test_write_wav(tmp_path):
@@ -264,6 +267,123 @@ def test_playback_controller_restarts_and_seeks_ten_seconds(tmp_path):
         controller.close()
 
 
+def test_playback_controller_forward_waits_for_full_ten_seconds(tmp_path):
+    recording = tmp_path / "sample.mp3"
+    recording.write_bytes(b"audio")
+    controller = PlaybackController(decoder=lambda _path: bytes(15 * 48_000))
+    try:
+        assert controller.control(recording, "forward").position_seconds == 10
+        assert controller.control(recording, "forward").position_seconds == 10
+    finally:
+        controller.close()
+
+
+def test_playback_controller_forward_clamps_to_live_edge(tmp_path):
+    recording = tmp_path / "sample.mp3"
+    recording.touch()
+    pending_generation_path(recording).touch()
+    stream = streaming_pcm_path(recording)
+    stream.write_bytes(bytes(15 * 48_000))
+    controller = PlaybackController()
+    try:
+        controller.control(recording, "forward")
+        deadline = time.monotonic() + 1
+        while len(controller._source_pcm) < stream.stat().st_size:
+            assert time.monotonic() < deadline
+            time.sleep(0.01)
+
+        controller.control(recording, "back")
+        assert controller.control(recording, "forward").position_seconds == 10
+        assert controller.control(recording, "forward").position_seconds == 15
+    finally:
+        controller.close()
+
+
+def test_playback_controller_plays_pcm_as_it_is_generated(tmp_path):
+    recording = tmp_path / "sample.mp3"
+    recording.touch()
+    pending_generation_path(recording).touch()
+    streaming_pcm_path(recording).touch()
+    device = SimpleNamespace(running=False)
+
+    def start(stream):
+        device.stream = stream
+        device.running = True
+
+    device.start = start
+    device.stop = lambda: setattr(device, "running", False)
+    device.close = device.stop
+    processed = threading.Event()
+
+    def change_tempo(pcm, _speed):
+        processed.set()
+        return pcm
+
+    controller = PlaybackController(
+        device_factory=lambda **_options: device,
+        tempo_changer=change_tempo,
+    )
+    try:
+        assert controller.control(recording, "toggle").playing is True
+        faster = controller.control(recording, "faster")
+        assert faster.speed == 1.25
+        assert faster.playing is True
+        assert bytes(device.stream.send(2)) == bytes(4)
+
+        streaming_pcm_path(recording).write_bytes(b"\x01\x00\x02\x00")
+        assert processed.wait(timeout=1)
+        assert bytes(device.stream.send(2)) == b"\x01\x00\x02\x00"
+        paused = controller.control(recording, "toggle")
+        assert paused.playing is False
+        assert paused.position_seconds > 0
+        resumed = controller.control(recording, "toggle")
+        assert resumed.playing is True
+        assert resumed.position_seconds == paused.position_seconds
+        assert (
+            controller.control(recording, "forward").position_seconds
+            == resumed.position_seconds
+        )
+
+        recording.write_bytes(b"complete")
+        pending_generation_path(recording).unlink()
+        deadline = time.monotonic() + 1
+        while controller._streaming_locked() and time.monotonic() < deadline:
+            time.sleep(0.01)
+        assert bytes(device.stream.send(2)) == bytes(4)
+        assert controller.control(recording, "toggle").playing is True
+    finally:
+        controller.close()
+
+
+def test_playback_controller_reloads_after_live_generation_fails(tmp_path):
+    recording = tmp_path / "sample.mp3"
+    recording.touch()
+    pending_generation_path(recording).touch()
+    streaming_pcm_path(recording).write_bytes(b"\x01\x00")
+    decoded = []
+
+    def decode(path):
+        decoded.append(path)
+        return b"\x02\x00"
+
+    controller = PlaybackController(decoder=decode)
+    try:
+        controller.control(recording, "forward")
+        recording.unlink()
+        pending_generation_path(recording).unlink()
+        deadline = time.monotonic() + 1
+        while controller._recording is not None and time.monotonic() < deadline:
+            time.sleep(0.01)
+
+        recording.write_bytes(b"regenerated")
+        state = controller.control(recording, "forward")
+
+        assert decoded == [recording.resolve()]
+        assert state.playing is False
+    finally:
+        controller.close()
+
+
 def test_playback_controller_changes_speed_from_half_to_double_at_same_position(
     tmp_path,
 ):
diff --git a/tests/test_cli.py b/tests/test_cli.py
index 184ee27..605a978 100644
--- a/tests/test_cli.py
+++ b/tests/test_cli.py
@@ -90,13 +90,12 @@ def test_serve_accepts_the_highest_valid_port():
         (
             "speak",
             (
-                "--markdown",
-                "--response-file",
                 "--output",
                 "--format",
                 "--play",
                 "--play-after",
                 "--controls",
+                "--wait",
                 "--no-service",
             ),
         ),
@@ -299,15 +298,10 @@ def speak(self, request):
 
     monkeypatch.setattr(cli, "Speaker", FakeSpeaker)
     output = tmp_path / "recording.wav"
-    response_file = tmp_path / "response.md"
-    response_file.write_text("# Written response", encoding="utf-8")
-
     cli.main(
         [
             "speak",
             "Visible text.",
-            "--response-file",
-            str(response_file),
             "--output",
             str(output),
             "--label",
@@ -326,6 +320,7 @@ def speak(self, request):
             "--play-after",
             "2",
             "--controls",
+            "--wait",
             "--model-id",
             "kokoro",
             "--variant",
@@ -340,7 +335,6 @@ def speak(self, request):
         SpeakRequest(
             text="Visible text.",
             selection=ModelSelection("kokoro", "fp16"),
-            response_markdown="# Written response",
             output=output,
             label="ignored",
             output_dir=tmp_path / "managed",
@@ -350,6 +344,7 @@ def speak(self, request):
             language="en-gb",
             play_after=2.0,
             controls=True,
+            wait=True,
             no_service=True,
             service_url="http://127.0.0.1:9000",
         )
@@ -379,48 +374,10 @@ def speak(self, request):
     assert json.loads(capsys.readouterr().out) == {"receipt": True}
 
 
-@pytest.mark.parametrize("positional", (True, False))
-def test_speak_accepts_inline_markdown_with_text_or_stdin(
-    positional, monkeypatch, capsys
-):
-    captured = []
-    text = "Update. Built successfully with uv."
-    markdown = (
-        "# Update\n\nBuilt **successfully** with [`uv`](https://docs.astral.sh/uv/)."
-    )
-
-    class Receipt:
-        def to_dict(self):
-            return {"receipt": True}
-
-    class FakeSpeaker:
-        def speak(self, request):
-            captured.append(request)
-            return Receipt()
-
-    monkeypatch.setattr(cli, "Speaker", FakeSpeaker)
-    if not positional:
-        monkeypatch.setattr(cli.sys, "stdin", io.StringIO(text))
-
-    cli.main(["speak", *([text] if positional else []), "--markdown", markdown])
-
-    assert captured[0].text == text
-    assert captured[0].response_markdown == markdown
-    assert json.loads(capsys.readouterr().out) == {"receipt": True}
-
-
-def test_speak_rejects_inline_markdown_with_response_file():
+@pytest.mark.parametrize("option", ("--markdown", "--response-file"))
+def test_speak_rejects_removed_response_options(option):
     with pytest.raises(SystemExit) as exit_info:
-        cli.build_parser().parse_args(
-            [
-                "speak",
-                "Narration",
-                "--markdown",
-                "# Response",
-                "--response-file",
-                "response.md",
-            ]
-        )
+        cli.build_parser().parse_args(["speak", "Narration", option, "response"])
 
     assert exit_info.value.code == 2
 
diff --git a/tests/test_controls.py b/tests/test_controls.py
index 7d788e8..ddf2e4a 100644
--- a/tests/test_controls.py
+++ b/tests/test_controls.py
@@ -67,8 +67,11 @@ def run(command):
     assert "UTExportedTypeDeclarations" not in info
     script = commands[0][-1]
     assert "on open location theURL" in script
+    assert "set idleTicks to 0" in script
+    assert "if idleTicks >= 5 then quit" in script
     assert "on open controlFiles" not in script
     assert "quoted form of controlValue" in script
+    assert commands[0][1] == "-s"
     assert sum(command[0].endswith("lsregister") for command in commands) == 2
     assert defaults == [True, True]
 
diff --git a/tests/test_delivery.py b/tests/test_delivery.py
index c6c0950..d67c462 100644
--- a/tests/test_delivery.py
+++ b/tests/test_delivery.py
@@ -26,8 +26,7 @@ def test_prepare_delivery_uses_http_player_audio_and_control_links(
 
     result = delivery.prepare_delivery(
         recording,
-        "Visible response text.",
-        source_text="Spoken narration.",
+        "Spoken narration.",
         language="en-gb",
         recordings_dir=tmp_path,
         controls=True,
@@ -41,6 +40,9 @@ def test_prepare_delivery_uses_http_player_audio_and_control_links(
     assert result.audio_url == (
         "http://127.0.0.1:49123/recordings/Daily%20update%20%26%20notes.mp3"
     )
+    assert result.stream_url == (
+        "http://127.0.0.1:49123/stream/Daily%20update%20%26%20notes.mp3"
+    )
     assert result.controls == {
         action: f"agent-voice://control/abcdefghijklmnopqrstuvwx/{action}"
         for action in ("toggle", "restart", "back", "forward", "slower", "faster")
@@ -160,8 +162,8 @@ def test_control_failure_keeps_normal_viewer_delivery(tmp_path, monkeypatch):
         controls=True,
     )
 
-    assert result.browser_url.endswith("/player/fallback.html")
     assert result.audio_url.endswith("/recordings/fallback.mp3")
+    assert result.browser_url.endswith("/player/fallback.html")
     assert result.recording_path == recording
     assert result.controls is None
     assert result.warning == (
diff --git a/tests/test_engine.py b/tests/test_engine.py
index f803a72..ca29898 100644
--- a/tests/test_engine.py
+++ b/tests/test_engine.py
@@ -6,7 +6,7 @@
 import pytest
 
 from agent_voice import kokoro as kokoro_module
-from agent_voice.kokoro import KokoroAdapter
+from agent_voice.kokoro import KOKORO_MAX_PHONEMES, KokoroAdapter, _split_phonemes
 from agent_voice.model import (
     ModelSelection,
     NamedVoice,
@@ -20,14 +20,22 @@
 class FakeKokoro:
     def __init__(self):
         self.speed = None
+        self.text = None
 
     def get_voices(self):
         return ["af_heart"]
 
     def create(self, text, voice, speed, lang):
+        self.text = text
         self.speed = speed
         return np.zeros(24_000, dtype=np.float32), 24_000
 
+    def create_chunks(self, text, voice, speed, lang):
+        self.text = text
+        self.speed = speed
+        yield np.zeros(240, dtype=np.float32), 24_000
+        yield np.ones(480, dtype=np.float32), 24_000
+
 
 def fake_model(monkeypatch):
     runtime = FakeKokoro()
@@ -64,6 +72,23 @@ def change_tempo(samples, sample_rate, factor):
     assert speech.duration_seconds == 1.0
 
 
+def test_streaming_preserves_model_chunks_and_post_processes_each(monkeypatch):
+    model, runtime = fake_model(monkeypatch)
+    tempo_factors = []
+
+    def change_tempo(samples, _sample_rate, factor):
+        tempo_factors.append(factor)
+        return samples
+
+    monkeypatch.setattr(kokoro_module, "change_tempo", change_tempo)
+
+    chunks = list(model.synthesize_stream(SynthesisRequest("Stream me", speed=1.5)))
+
+    assert [len(chunk.samples) for chunk in chunks] == [240, 480]
+    assert runtime.speed == 1.0
+    assert tempo_factors == [1.5, 1.5]
+
+
 @pytest.mark.parametrize("speed", [0.49, 4.01])
 def test_speed_outside_supported_range_is_rejected(monkeypatch, speed):
     model, _ = fake_model(monkeypatch)
@@ -71,6 +96,26 @@ def test_speed_outside_supported_range_is_rejected(monkeypatch, speed):
         model.synthesize(SynthesisRequest("Invalid speed", speed=speed))
 
 
+def test_kokoro_accepts_up_to_50_000_characters(monkeypatch):
+    model, runtime = fake_model(monkeypatch)
+    text = "a" * 50_000
+
+    model.synthesize(SynthesisRequest(text))
+
+    assert runtime.text == text
+    with pytest.raises(ValueError, match="maximum 50,000 characters"):
+        model.synthesize(SynthesisRequest(text + "a"))
+
+
+def test_phoneme_splitter_preserves_long_spans_at_the_batch_boundary():
+    phonemes = "a" * (KOKORO_MAX_PHONEMES - 1) + "." + "b" * (KOKORO_MAX_PHONEMES + 17)
+
+    chunks = _split_phonemes(phonemes)
+
+    assert "".join(chunks) == phonemes
+    assert all(0 < len(chunk) <= KOKORO_MAX_PHONEMES for chunk in chunks)
+
+
 def test_kokoro_rejects_reference_audio_through_the_model_interface(
     monkeypatch, tmp_path
 ):
diff --git a/tests/test_service.py b/tests/test_service.py
index 3bbce10..5939308 100644
--- a/tests/test_service.py
+++ b/tests/test_service.py
@@ -10,16 +10,20 @@
 import numpy as np
 import pytest
 
+from agent_voice import audio as audio_module
 from agent_voice import client, service
 from agent_voice.client import (
     ServiceUnavailable,
     ensure_service,
     health_check,
     request_speech,
+    request_speech_background,
     set_service_timeout,
     stop_service,
     validate_service_url,
 )
+from agent_voice.media import generating_audio
+from agent_voice.paths import pending_generation_path, streaming_pcm_path
 from agent_voice.config import update_defaults
 from agent_voice.model import (
     ModelDescriptor,
@@ -101,8 +105,20 @@ def test_server_rejects_invalid_ports(port):
         create_server(object(), "127.0.0.1", port)
 
 
-def test_serve_reports_the_actual_bound_port(monkeypatch, capsys):
+def test_serve_reports_the_actual_bound_port_and_recovers_interrupted_generation(
+    tmp_path, monkeypatch, capsys
+):
+    monkeypatch.setenv("AGENT_VOICE_HOME", str(tmp_path))
     events = []
+    recordings = tmp_path / "recordings"
+    recordings.mkdir()
+    abandoned = recordings / "abandoned.mp3"
+    completed = recordings / "completed.mp3"
+    abandoned.write_bytes(generating_audio("mp3"))
+    completed.write_bytes(b"completed")
+    for recording in (abandoned, completed):
+        pending_generation_path(recording).touch()
+        streaming_pcm_path(recording).write_bytes(b"pcm")
 
     class FakeServer:
         server_port = 49_123
@@ -119,6 +135,11 @@ def server_close(self):
 
     assert "http://127.0.0.1:49123" in capsys.readouterr().out
     assert events == ["serve", "close"]
+    assert not abandoned.exists()
+    assert completed.read_bytes() == b"completed"
+    for recording in (abandoned, completed):
+        assert not pending_generation_path(recording).exists()
+        assert not streaming_pcm_path(recording).exists()
 
 
 @pytest.mark.parametrize(
@@ -181,7 +202,9 @@ def test_legacy_speak_endpoint_is_not_available():
         assert json.loads(rejected.value.read())["error"] == "Not found"
 
 
-def test_health_and_speech_contract(tmp_path):
+def test_health_and_speech_contract(tmp_path, monkeypatch):
+    monkeypatch.setenv("AGENT_VOICE_HOME", str(tmp_path))
+
     class FakeModel:
         descriptor = ModelDescriptor(
             selection=ModelSelection("test-model", "test-variant"),
@@ -246,6 +269,7 @@ def synthesize(self, request):
     assert health["model"] == "Test Model"
     assert health["model_id"] == "test-model"
     assert health["variant"] == "test-variant"
+    assert health["recording_root"] == str(tmp_path / "recordings")
     assert health["service_timeout_minutes"] is None
     assert hostile.value.code == 403
     assert json.loads(hostile.value.read())["error"] == "Host must be localhost"
@@ -261,6 +285,199 @@ def synthesize(self, request):
     assert (tmp_path / "service.wav").stat().st_size > 44
 
 
+def test_service_accepts_50_000_unicode_characters(tmp_path):
+    text = "א" * 50_000
+
+    class FakeModel:
+        def synthesize(self, request):
+            assert request.text == text
+            return Speech(np.zeros(240, dtype=np.float32), 24_000, 0.01)
+
+    with _running_server(FakeModel()) as (_, url):
+        result = request_speech(
+            url,
+            text,
+            tmp_path / "unicode.wav",
+            "wav",
+            "af_heart",
+            1.0,
+            "en-us",
+        )
+
+    assert result.path.exists()
+
+
+@pytest.mark.parametrize("audio_format", ("wav", "mp3", "opus", "m4a"))
+def test_background_speech_returns_before_generation_finishes(
+    tmp_path, monkeypatch, audio_format
+):
+    monkeypatch.setenv("AGENT_VOICE_HOME", str(tmp_path))
+    destination = tmp_path / "recordings" / f"live.{audio_format}"
+    destination.parent.mkdir()
+    destination.touch()
+    generation_waiting = threading.Event()
+    finish_generation = threading.Event()
+
+    class StreamingModel:
+        descriptor = ModelDescriptor(
+            selection=ModelSelection("test-model", "test-variant"),
+            display_name="Test Model",
+            runtime="test-runtime",
+            capabilities=frozenset(),
+        )
+
+        def synthesize_stream(self, request):
+            assert request.text == "stream this"
+            yield Speech(np.ones(240, dtype=np.float32) * 0.25, 24_000, 0.01)
+            generation_waiting.set()
+            assert finish_generation.wait(timeout=2)
+            yield Speech(np.ones(240, dtype=np.float32) * 0.5, 24_000, 0.01)
+
+    with _running_server(StreamingModel()) as (_, url):
+        recording = request_speech_background(
+            url,
+            "stream this",
+            destination,
+            audio_format,
+            "af_heart",
+            1.0,
+            "en-us",
+            selection=ModelSelection("test-model", "test-variant"),
+        )
+        assert generation_waiting.wait(timeout=1)
+        assert recording.path == destination.resolve()
+        assert pending_generation_path(destination).is_file()
+        assert streaming_pcm_path(destination).stat().st_size == 480
+        assert audio_module._decode_for_playback(destination)
+
+        finish_generation.set()
+        deadline = time.monotonic() + 2
+        while (
+            pending_generation_path(destination).is_file()
+            and time.monotonic() < deadline
+        ):
+            time.sleep(0.01)
+
+    assert not pending_generation_path(destination).exists()
+    assert audio_module._decode_for_playback(destination)
+
+
+def test_background_speech_rejects_a_different_client_recording_root(
+    tmp_path, monkeypatch
+):
+    monkeypatch.setenv("AGENT_VOICE_HOME", str(tmp_path / "service"))
+    destination = tmp_path / "client" / "mismatch.mp3"
+
+    class StreamingModel:
+        descriptor = ModelDescriptor(
+            selection=ModelSelection("test-model", "test-variant"),
+            display_name="Test Model",
+            runtime="test-runtime",
+            capabilities=frozenset(),
+        )
+
+    with _running_server(StreamingModel()) as (_, url):
+        with pytest.raises(ServiceUnavailable, match="recording directory mismatch"):
+            request_speech_background(
+                url,
+                "do not start",
+                destination,
+                "mp3",
+                "af_heart",
+                1.0,
+                "en-us",
+                selection=ModelSelection("test-model", "test-variant"),
+            )
+
+    assert not destination.exists()
+
+
+def test_failed_background_generation_releases_the_reserved_recording(
+    tmp_path, monkeypatch
+):
+    monkeypatch.setenv("AGENT_VOICE_HOME", str(tmp_path))
+    destination = tmp_path / "recordings" / "failed.mp3"
+    destination.parent.mkdir()
+    destination.touch()
+    generation_waiting = threading.Event()
+    fail_generation = threading.Event()
+
+    class FailingModel:
+        descriptor = ModelDescriptor(
+            selection=ModelSelection("test-model", "test-variant"),
+            display_name="Test Model",
+            runtime="test-runtime",
+            capabilities=frozenset(),
+        )
+
+        def synthesize_stream(self, _request):
+            yield Speech(np.ones(240, dtype=np.float32) * 0.25, 24_000, 0.01)
+            generation_waiting.set()
+            assert fail_generation.wait(timeout=2)
+            raise RuntimeError("generation failed")
+
+    with _running_server(FailingModel()) as (_, url):
+        request_speech_background(
+            url,
+            "fail",
+            destination,
+            "mp3",
+            "af_heart",
+            1.0,
+            "en-us",
+            selection=ModelSelection("test-model", "test-variant"),
+        )
+        assert generation_waiting.wait(timeout=1)
+        fail_generation.set()
+        deadline = time.monotonic() + 1
+        while (
+            pending_generation_path(destination).is_file()
+            and time.monotonic() < deadline
+        ):
+            time.sleep(0.01)
+
+    assert not destination.exists()
+    assert not pending_generation_path(destination).exists()
+
+
+def test_background_speech_rejects_invalid_input_before_started_receipt(
+    tmp_path, monkeypatch
+):
+    monkeypatch.setenv("AGENT_VOICE_HOME", str(tmp_path))
+    destination = tmp_path / "recordings" / "invalid.mp3"
+    destination.parent.mkdir()
+    destination.touch()
+
+    class InvalidModel:
+        descriptor = ModelDescriptor(
+            selection=ModelSelection("test-model", "test-variant"),
+            display_name="Test Model",
+            runtime="test-runtime",
+            capabilities=frozenset(),
+        )
+
+        def synthesize_stream(self, _request):
+            raise ValueError("invalid voice")
+            yield
+
+    with _running_server(InvalidModel()) as (_, url):
+        with pytest.raises(ValueError, match="invalid voice"):
+            request_speech_background(
+                url,
+                "fail before start",
+                destination,
+                "mp3",
+                "missing",
+                1.0,
+                "en-us",
+                selection=ModelSelection("test-model", "test-variant"),
+            )
+
+    assert not destination.exists()
+    assert not pending_generation_path(destination).exists()
+    assert not streaming_pcm_path(destination).exists()
+
+
 def test_health_remains_available_while_speech_is_running(tmp_path):
     synthesis_started = threading.Event()
     finish_synthesis = threading.Event()
diff --git a/tests/test_speaking.py b/tests/test_speaking.py
index 43d93d1..8a1d7c1 100644
--- a/tests/test_speaking.py
+++ b/tests/test_speaking.py
@@ -27,6 +27,7 @@ def __init__(
         self.audio = audio
         self.error = error
         self.requests = []
+        self.background_requests = []
 
     def generate(self, request):
         self.requests.append(request)
@@ -46,13 +47,27 @@ def generate(self, request):
             backend=self.backend,
         )
 
+    def generate_background(self, request):
+        self.background_requests.append(request)
+        if self.error is not None:
+            raise self.error
+        return Recording(
+            path=request.output.destination.expanduser().resolve(),
+            format=request.output.audio_format,
+            voice=request.voice,
+            speed=request.speed,
+            sample_rate=None,
+            duration_seconds=None,
+            generation_seconds=None,
+            backend=self.backend,
+        )
+
 
 def delivery_success(calls: list | None = None):
     def prepare(
         recording,
         text,
         *,
-        source_text,
         language,
         audio_format,
         recordings_dir,
@@ -63,7 +78,6 @@ def prepare(
                 (
                     recording,
                     text,
-                    source_text,
                     language,
                     audio_format,
                     recordings_dir,
@@ -74,6 +88,7 @@ def prepare(
         return Delivery(
             browser_url="http://127.0.0.1:49123/player/recording.html",
             audio_url="http://127.0.0.1:49123/recordings/recording.mp3",
+            stream_url="http://127.0.0.1:49123/stream/recording.mp3",
             recording_path=resolved,
         )
 
@@ -130,7 +145,7 @@ def test_service_generation_uses_configured_timeout(tmp_path):
         tmp_path,
         defaults=defaults,
         service=service,
-    ).speak(SpeakRequest("Visible text.", SELECTION))
+    ).speak(SpeakRequest("Visible text.", SELECTION, wait=True))
 
     assert receipt.recording.backend == "service"
     assert receipt.recording.path.read_bytes() == b"service"
@@ -151,7 +166,7 @@ def test_unavailable_service_falls_back_to_embedded(tmp_path):
         embedded=embedded,
         service=service,
         notices=notices,
-    ).speak(SpeakRequest("Visible text.", SELECTION))
+    ).speak(SpeakRequest("Visible text.", SELECTION, wait=True))
 
     assert receipt.recording.backend == "local"
     assert receipt.service_fallback is True
@@ -170,7 +185,7 @@ def test_non_availability_service_errors_do_not_fallback(tmp_path):
             tmp_path,
             embedded=embedded,
             service=service,
-        ).speak(SpeakRequest("Visible text.", SELECTION))
+        ).speak(SpeakRequest("Visible text.", SELECTION, wait=True))
 
     assert embedded.requests == []
 
@@ -248,7 +263,7 @@ def test_environment_recording_root_overrides_config(tmp_path, monkeypatch):
     ).speak(SpeakRequest("Visible text.", SELECTION, no_service=True))
 
     assert receipt.recording.path.parent == environment
-    assert calls[0][5] == environment
+    assert calls[0][4] == environment
     assert not configured.exists()
 
 
@@ -288,7 +303,7 @@ def test_live_config_cli_and_environment_precedence(tmp_path, monkeypatch):
     assert receipt.recording.format == "wav"
     assert receipt.recording.voice == "af_nova"
     assert receipt.recording.speed == 1.15
-    assert calls[0][5] == environment
+    assert calls[0][4] == environment
 
 
 def test_exact_output_takes_precedence_and_extension_selects_format(tmp_path):
@@ -507,7 +522,6 @@ def test_delivery_receives_the_planned_recording_root(tmp_path):
         (
             output,
             "Visible text.",
-            "Visible text.",
             "en-us",
             "mp3",
             recording_root,
@@ -517,24 +531,57 @@ def test_delivery_receives_the_planned_recording_root(tmp_path):
     assert receipt.delivery.browser_url is not None
 
 
-def test_delivery_prefers_the_written_response(tmp_path):
+def test_delivery_uses_the_spoken_text(tmp_path):
     calls = []
 
     make_speaker(tmp_path, delivery=delivery_success(calls)).speak(
         SpeakRequest(
             "Spoken narration.",
             SELECTION,
-            response_markdown="# Written response",
             language="he-il",
             controls=True,
             no_service=True,
         )
     )
 
-    assert calls[0][1] == "# Written response"
-    assert calls[0][2] == "Spoken narration."
-    assert calls[0][3] == "he-il"
-    assert calls[0][6] is True
+    assert calls[0][1] == "Spoken narration."
+    assert calls[0][2] == "he-il"
+    assert calls[0][5] is True
+
+
+def test_controls_start_background_generation_without_changing_delivery(tmp_path):
+    service = FakeGenerator(backend="service")
+    receipt = make_speaker(tmp_path, service=service).speak(
+        SpeakRequest("Spoken narration.", SELECTION, controls=True)
+    )
+
+    assert len(service.background_requests) == 1
+    assert service.requests == []
+    assert receipt.generation == {"state": "started"}
+    assert receipt.delivery.browser_url is not None
+    payload = receipt.to_dict()
+    assert payload["path"] == str(receipt.recording.path)
+    assert payload["file_uri"] == receipt.recording.path.as_uri()
+    assert "recording_name" not in payload
+    assert payload["delivery"]["stream_url"] == receipt.delivery.stream_url
+    assert "audio_url" not in payload["delivery"]
+    assert "recording_path" not in payload["delivery"]
+
+
+def test_portable_delivery_returns_optimistic_links_by_default(tmp_path):
+    service = FakeGenerator(backend="service")
+    receipt = make_speaker(tmp_path, service=service).speak(
+        SpeakRequest("Spoken narration.", SELECTION)
+    )
+
+    assert len(service.background_requests) == 1
+    payload = receipt.to_dict()
+    assert payload["generation"] == {"state": "started"}
+    assert payload["path"] == str(receipt.recording.path)
+    assert payload["file_uri"] == receipt.recording.path.as_uri()
+    assert "recording_name" not in payload
+    assert payload["delivery"]["browser_url"] == receipt.delivery.browser_url
+    assert payload["delivery"]["stream_url"] == receipt.delivery.stream_url
 
 
 def test_delivery_failure_facts_are_typed_serialized_and_reported(tmp_path):
@@ -544,7 +591,6 @@ def fallback(
         recording,
         text,
         *,
-        source_text,
         language,
         audio_format,
         recordings_dir,
diff --git a/tests/test_viewer.py b/tests/test_viewer.py
index 506e211..a34574c 100644
--- a/tests/test_viewer.py
+++ b/tests/test_viewer.py
@@ -17,6 +17,8 @@
 from agent_voice import viewer as viewer_module
 from agent_voice import viewer_server
 from agent_voice import controls as controls_module
+from agent_voice.media import CONTENT_TYPES, generating_audio
+from agent_voice.paths import pending_generation_path, streaming_pcm_path
 from agent_voice.viewer import (
     VIEWER_PROTOCOL,
     Viewer,
@@ -27,11 +29,12 @@
     publish_player,
     publish_recording,
     publish_source,
+    recording_player_url,
+    recording_stream_url,
     recording_urls,
     recording_control_urls,
     source_path,
     stop_viewer,
-    transcript_path,
 )
 from agent_voice.viewer_server import DEFAULT_VIEWER_PORT, Handler, Server
 
@@ -61,14 +64,9 @@ def _running_viewer(recordings: Path):
 def test_viewer_serves_supported_audio_and_dynamic_player(tmp_path, name, content_type):
     recording = tmp_path / name
     recording.write_bytes(b"0123456789")
-    player_name = publish_player(
-        recording,
-        '# Visible **response**\n\n<script>alert("no")</script>\n\n'
-        "> A quotation\n\n- [x] Done\n- [ ] Pending\n\n"
-        "> [!NOTE]\n> An alert\n\nhttps://example.com\n\n"
-        '```python\nprint("hello")\n```\n\n'
-        "```not-a-language\n<plain>\n```",
-    )
+    narration = 'Visible response.\n<script>alert("no")</script>'
+    publish_source(recording, narration)
+    player_name = publish_player(recording)
 
     with _running_viewer(tmp_path) as (_, url):
         with urllib.request.urlopen(f"{url}/recordings/{name}") as response:
@@ -86,36 +84,62 @@ def test_viewer_serves_supported_audio_and_dynamic_player(tmp_path, name, conten
             assert 'rel="icon"' in document
             assert 'type="image/svg+xml"' in document
             assert 'href="data:image/svg+xml;base64,' in document
-            assert 'class="recording-icon"' in document
             assert document.count('src="data:image/svg+xml;base64,') == 1
-            assert ">Response</h2>" not in document
-            assert document.index("<audio ") < document.index('class="recording-icon"')
-            assert (
-                '<div class="response"><h1>Visible <strong>response</strong></h1>'
-                in document
-            )
-            assert '<ul class="contains-task-list">' in document
-            assert 'type="checkbox" checked=""' in document
-            assert '<span class="nb">print</span>' in document
-            assert '<span style="color:' not in document
-            assert "&quot;hello&quot;" in document
-            assert '<code class="language-not-a-language">&lt;plain&gt;' in document
-            assert "<blockquote>" in document
-            assert 'class="markdown-alert markdown-alert-note"' in document
-            assert '<a href="https://example.com">https://example.com</a>' in document
+            assert "<h1>Agent Voice</h1>" in document
+            assert "<summary>Narration text</summary>" in document
+            assert 'class="narration">Visible response.\n&lt;script&gt;' in document
+            assert "white-space: pre-wrap" in document
             assert "prefers-color-scheme: dark" in document
             assert "&lt;script&gt;" in document
             assert "<script>" not in document
 
     assert recording.is_file()
-    assert transcript_path(recording).is_file()
-    assert transcript_path(recording).read_text() == (
-        '# Visible **response**\n\n<script>alert("no")</script>\n\n'
-        "> A quotation\n\n- [x] Done\n- [ ] Pending\n\n"
-        "> [!NOTE]\n> An alert\n\nhttps://example.com\n\n"
-        '```python\nprint("hello")\n```\n\n'
-        "```not-a-language\n<plain>\n```"
-    )
+    assert source_path(recording).read_text() == narration
+
+
+@pytest.mark.parametrize("name", ("live.wav", "live.mp3", "live.opus", "live.m4a"))
+def test_player_uses_native_live_audio_while_recording_is_generated(tmp_path, name):
+    recording = tmp_path / name
+    recording.touch()
+    publish_source(recording, "Live response")
+    player_name = publish_player(recording)
+    pending_generation_path(recording).touch()
+    streaming_pcm_path(recording).touch()
+
+    with _running_viewer(tmp_path) as (_, url):
+        with urllib.request.urlopen(f"{url}/player/{player_name}") as response:
+            document = response.read().decode()
+        assert f'src="/stream/{name}"' in document
+        assert 'type="audio/wav"' in document
+        with pytest.raises(urllib.error.HTTPError) as error:
+            urllib.request.urlopen(f"{url}/recordings/{name}")
+        assert error.value.code == 425
+
+        def finish_generation():
+            time.sleep(0.05)
+            streaming_pcm_path(recording).write_bytes(b"\x01\x00\x02\x00")
+            recording.write_bytes(b"final audio")
+            pending_generation_path(recording).unlink()
+
+        writer = threading.Thread(target=finish_generation)
+        writer.start()
+        with urllib.request.urlopen(f"{url}/stream/{name}") as response:
+            audio = response.read()
+            assert response.headers["Content-Type"] == "audio/wav"
+        writer.join(timeout=1)
+
+        with urllib.request.urlopen(f"{url}/stream/{name}") as response:
+            assert response.url == f"{url}/stream/{name}"
+            assert response.status == 200
+            assert (
+                response.headers["Content-Type"] == CONTENT_TYPES[name.split(".")[-1]]
+            )
+            assert response.read() == b"final audio"
+        assert streaming_pcm_path(recording).is_file()
+
+    assert audio[:4] == b"RIFF"
+    assert audio[8:12] == b"WAVE"
+    assert audio[44:] == b"\x01\x00\x02\x00"
 
 
 def test_viewer_rejects_legacy_player_links(tmp_path):
@@ -136,13 +160,21 @@ def test_player_urls_keep_audio_formats_distinct(tmp_path):
     mp3.write_bytes(b"mp3")
     wav.write_bytes(b"wav")
 
-    mp3_name = publish_player(mp3, "MP3")
-    wav_name = publish_player(wav, "WAV")
-    mp3_url, _ = recording_urls(viewer, mp3, mp3_name)
-    wav_url, _ = recording_urls(viewer, wav, wav_name)
+    publish_source(mp3, "MP3")
+    publish_source(wav, "WAV")
+    mp3_name = publish_player(mp3)
+    wav_name = publish_player(wav)
+    mp3_url = recording_player_url(viewer, mp3_name)
+    wav_url = recording_player_url(viewer, wav_name)
+    _, mp3_audio_url = recording_urls(viewer, mp3, mp3_name)
+    _, wav_audio_url = recording_urls(viewer, wav, wav_name)
+    mp3_stream_url = recording_stream_url(viewer, mp3)
 
     assert mp3_url.endswith("/player/sample.html")
     assert wav_url.endswith("/player/sample-2.html")
+    assert mp3_audio_url.endswith("/recordings/sample.mp3")
+    assert wav_audio_url.endswith("/recordings/sample.wav")
+    assert mp3_stream_url.endswith("/stream/sample.mp3")
     with _running_viewer(tmp_path) as (_, url):
         with urllib.request.urlopen(f"{url}/player/sample.html") as response:
             assert 'src="/recordings/sample.mp3"' in response.read().decode()
@@ -403,7 +435,7 @@ def unexpected_lookup(host):
         assert server.server_port > 0
 
 
-def test_viewer_cleans_at_startup_and_every_six_hours(tmp_path, monkeypatch):
+def test_viewer_cleans_at_startup_and_every_hour(tmp_path, monkeypatch):
     calls = []
     now = [100.0]
     monkeypatch.setattr(
@@ -416,7 +448,7 @@ def test_viewer_cleans_at_startup_and_every_six_hours(tmp_path, monkeypatch):
     with Server(tmp_path) as server:
         assert calls == []
         server.service_actions()
-        now[0] += 6 * 60 * 60 - 1
+        now[0] += 60 * 60 - 1
         server.service_actions()
         now[0] += 1
         server.service_actions()
@@ -464,10 +496,10 @@ def test_expired_recordings_keep_sources_and_unmanaged_audio(tmp_path):
     for recording in (expired, fresh, unmanaged, unrelated_sidecar):
         recording.write_bytes(b"audio")
     publish_source(expired, "Editable old text.")
-    publish_player(expired, "Visible old text.")
+    publish_player(expired)
     publish_language(expired, "en-us")
     publish_source(fresh, "Editable fresh text.")
-    publish_player(fresh, "Visible fresh text.")
+    publish_player(fresh)
     publish_language(fresh, "en-us")
     publish_source(unrelated_sidecar, "Not Agent Voice metadata.")
     os.utime(expired, (now - delete_after - 1,) * 2)
@@ -483,10 +515,43 @@ def test_expired_recordings_keep_sources_and_unmanaged_audio(tmp_path):
     assert unrelated_sidecar.is_file()
 
 
+def test_completed_stream_sidecars_expire_without_touching_active_generation(tmp_path):
+    now = time.time()
+    completed = tmp_path / "completed.mp3"
+    active = tmp_path / "active.mp3"
+    stale = tmp_path / "stale.mp3"
+    for recording in (completed, active, stale):
+        recording.touch()
+        streaming_pcm_path(recording).write_bytes(b"pcm")
+        os.utime(
+            streaming_pcm_path(recording),
+            (now - 60 * 60 - 1,) * 2,
+        )
+    pending_generation_path(active).touch()
+    os.utime(
+        pending_generation_path(active),
+        (now - 60 * 60 - 1,) * 2,
+    )
+    pending_generation_path(stale).touch()
+    stale.write_bytes(generating_audio("mp3"))
+    os.utime(
+        pending_generation_path(stale),
+        (now - 6 * 60 * 60 - 1,) * 2,
+    )
+
+    delete_expired_recordings(tmp_path, now=now)
+
+    assert not streaming_pcm_path(completed).exists()
+    assert streaming_pcm_path(active).is_file()
+    assert not stale.exists()
+    assert not pending_generation_path(stale).exists()
+    assert not streaming_pcm_path(stale).exists()
+
+
 def test_viewer_regenerates_missing_audio_from_source(tmp_path, monkeypatch):
     recording = tmp_path / "requested.mp3"
     publish_source(recording, "Current editable text.")
-    publish_player(recording, "Visible response.")
+    publish_player(recording)
     publish_language(recording, "en-us")
     regenerated = []
 
@@ -507,7 +572,7 @@ def test_viewer_retries_when_cleanup_removes_audio_before_open(tmp_path, monkeyp
     recording = tmp_path / "requested.mp3"
     recording.write_bytes(b"expired")
     publish_source(recording, "Current editable text.")
-    publish_player(recording, "Visible response.")
+    publish_player(recording)
     publish_language(recording, "en-us")
     monkeypatch.setattr(
         viewer_server,
@@ -533,7 +598,7 @@ def remove_before_open(self, path, content_type, head):
 def test_viewer_reports_regeneration_failure(tmp_path, monkeypatch):
     recording = tmp_path / "requested.mp3"
     publish_source(recording, "Current editable text.")
-    publish_player(recording, "Visible response.")
+    publish_player(recording)
     publish_language(recording, "en-us")
     monkeypatch.setattr(
         viewer_server,
diff --git a/uv.lock b/uv.lock
index eb40b41..b9ddd19 100644
--- a/uv.lock
+++ b/uv.lock
@@ -8,18 +8,15 @@ resolution-markers = [
 
 [[package]]
 name = "agent-voice"
-version = "0.8.0"
+version = "0.9.0"
 source = { editable = "." }
 dependencies = [
     { name = "filelock" },
     { name = "imageio-ffmpeg" },
     { name = "kokoro-onnx" },
-    { name = "linkify-it-py" },
-    { name = "markdown-it-py" },
     { name = "miniaudio" },
     { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" },
     { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" },
-    { name = "pygments" },
 ]
 
 [package.dev-dependencies]
@@ -33,11 +30,8 @@ requires-dist = [
     { name = "filelock", specifier = ">=3.20,<4" },
     { name = "imageio-ffmpeg", specifier = "==0.6.0" },
     { name = "kokoro-onnx", specifier = "==0.5.0" },
-    { name = "linkify-it-py", specifier = ">=2,<3" },
-    { name = "markdown-it-py", specifier = ">=4.2,<5" },
     { name = "miniaudio", specifier = "==1.71" },
     { name = "numpy", specifier = ">=2,<3" },
-    { name = "pygments", specifier = ">=2.19,<3" },
 ]
 
 [package.metadata.requires-dev]
@@ -275,39 +269,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/0a/21/b48b9e8408b3faec9fb7cb2f68352c7724add35a980c948eaceb29ac41e4/language_tags-1.3.1-py3-none-any.whl", hash = "sha256:f7db7ef8879523019603e09644a86d95ba60595ce5e5ea82d46e8971b0f68f7b", size = 216654, upload-time = "2026-05-08T11:46:17.836Z" },
 ]
 
-[[package]]
-name = "linkify-it-py"
-version = "2.1.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "uc-micro-py" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/2e/c9/06ea13676ef354f0af6169587ae292d3e2406e212876a413bf9eece4eb23/linkify_it_py-2.1.0.tar.gz", hash = "sha256:43360231720999c10e9328dc3691160e27a718e280673d444c38d7d3aaa3b98b", size = 29158, upload-time = "2026-03-01T07:48:47.683Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/b4/de/88b3be5c31b22333b3ca2f6ff1de4e863d8fe45aaea7485f591970ec1d3e/linkify_it_py-2.1.0-py3-none-any.whl", hash = "sha256:0d252c1594ecba2ecedc444053db5d3a9b7ec1b0dd929c8f1d74dce89f86c05e", size = 19878, upload-time = "2026-03-01T07:48:46.098Z" },
-]
-
-[[package]]
-name = "markdown-it-py"
-version = "4.2.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "mdurl" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/06/ff/7841249c247aa650a76b9ee4bbaeae59370dc8bfd2f6c01f3630c35eb134/markdown_it_py-4.2.0.tar.gz", hash = "sha256:04a21681d6fbb623de53f6f364d352309d4094dd4194040a10fd51833e418d49", size = 82454, upload-time = "2026-05-07T12:08:28.36Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/b3/81/4da04ced5a082363ecfa159c010d200ecbd959ae410c10c0264a38cac0f5/markdown_it_py-4.2.0-py3-none-any.whl", hash = "sha256:9f7ebbcd14fe59494226453aed97c1070d83f8d24b6fc3a3bcf9a38092641c4a", size = 91687, upload-time = "2026-05-07T12:08:27.182Z" },
-]
-
-[[package]]
-name = "mdurl"
-version = "0.1.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729, upload-time = "2022-08-14T12:40:10.846Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" },
-]
-
 [[package]]
 name = "miniaudio"
 version = "1.71"
@@ -803,15 +764,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/49/d3/b8441a820a491ddfc024b0b0cf0393375b75ea13866d9c66727e54c2fc80/typing_extensions-4.16.0-py3-none-any.whl", hash = "sha256:481caa481374e813c1b176ada14e97f1f67a4539ce9cfeb3f350d78d6370c2e8", size = 45571, upload-time = "2026-07-02T08:40:04.659Z" },
 ]
 
-[[package]]
-name = "uc-micro-py"
-version = "2.0.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/78/67/9a363818028526e2d4579334460df777115bdec1bb77c08f9db88f6389f2/uc_micro_py-2.0.0.tar.gz", hash = "sha256:c53691e495c8db60e16ffc4861a35469b0ba0821fe409a8a7a0a71864d33a811", size = 6611, upload-time = "2026-03-01T06:31:27.526Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/61/73/d21edf5b204d1467e06500080a50f79d49ef2b997c79123a536d4a17d97c/uc_micro_py-2.0.0-py3-none-any.whl", hash = "sha256:3603a3859af53e5a39bc7677713c78ea6589ff188d70f4fee165db88e22b242c", size = 6383, upload-time = "2026-03-01T06:31:26.257Z" },
-]
-
 [[package]]
 name = "uritemplate"
 version = "4.2.0"