feat: bounded pre-gen, cancellation, disk cache pruning, GPU lock

- tts.py: limit pre-gen to first 3 chunks (configurable via env vars),
cancel_pregeneration() for Ask/book-switch, LRU eviction of story cache,
disk cache pruning (max 400 files / 512MB), GPU_INFERENCE_LOCK integration
- app.py: cancel pregen on Ask and book select, show target/error status
- inference_lfm.py: GPU lock around generate, improved error handling
- qa_flow.py: release_audio_submission for retry on error
- test_modules/test_tts_pregen.py: new test for pregen flow

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

app.py

@@ -9,6 +9,7 @@ import time
 from pathlib import Path
 
 from tts import (
+    cancel_pregeneration,
     generate_audio_stream,
     get_pregeneration_status,
     pregenerate_story_audio,
@@ -16,7 +17,7 @@ from tts import (
 )
 from inference import transcribe_audio, answer_story_question
 from inference_lfm import answer_question_audio
-from qa_flow import build_qa_response, claim_audio_submission
+from qa_flow import build_qa_response, claim_audio_submission, release_audio_submission
 from runtime_config import SAMPLE_SOUNDS_DIR, gradio_allowed_paths
 from voice_clone import load_default_profile, list_saved_profiles
 
@@ -698,23 +699,40 @@ with gr.Blocks(title="MomsVoice", css=css_code) as demo:
         total = max(len(paras) - 1, 0)
         tts_chunks = split_into_chunks("\n\n".join(paras))
         
-        # Pre-generate all audio in background for faster playback.
+        # Pre-generate only the first few chunks in background for fast start.
+        cancel_pregeneration()
         pregenerate_story_audio(tts_chunks, voice_profile_id=profile_id)
 
         pregen = get_pregeneration_status(tts_chunks, voice_profile_id=profile_id)
         warmed = int(pregen["cached"])
         total_chunks = int(pregen["total"])
+        target_chunks = int(pregen.get("target", min(total_chunks, 3)))
+        errors = int(pregen.get("errors", 0))
         if pregen["complete"]:
             chunk_text = f"{warmed} / {total_chunks} chunks cached — ready"
             chunk_color = "#4ade80"
+            status_label = "READY"
+            status_color = "#94a3b8"
+        elif warmed >= target_chunks and errors == 0:
+            chunk_text = f"First {target_chunks} chunks cached — tap Play"
+            chunk_color = "#4ade80"
+            status_label = "READY — FIRST CHUNKS CACHED"
+            status_color = "#4ade80"
+        elif errors:
+            chunk_text = f"Warmup hit {errors} error(s); Play will generate on demand"
+            chunk_color = "#ef4444"
+            status_label = "READY — ON-DEMAND AUDIO"
+            status_color = "#f59e0b"
         else:
-            chunk_text = f"Warming audio: {warmed} / {total_chunks} chunks cached — tap Play anytime"
+            chunk_text = f"Warming first {target_chunks} chunks: {warmed} / {target_chunks} cached — tap Play anytime"
             chunk_color = "#f59e0b"
+            status_label = "WARMING AUDIO"
+            status_color = "#f59e0b"
         chunk_html = f"""<div style="margin-top: 8px; font-size: 10px; color: {chunk_color}; font-family: monospace; text-align: center;">{chunk_text}</div>"""
-        status_html = """
+        status_html = f"""
             <div style="margin-top: 12px; display: flex; align-items: center; gap: 10px; justify-content: center;">
-                <span style="width: 8px; height: 8px; border-radius: 50%; background: #94a3b8; display: inline-block;"></span>
-                <span style="font-size: 11px; color: #94a3b8; font-family: monospace;">READY</span>
+                <span style="width: 8px; height: 8px; border-radius: 50%; background: {status_color}; display: inline-block;"></span>
+                <span style="font-size: 11px; color: {status_color}; font-family: monospace;">{status_label}</span>
             </div>
         """
         story_html = render_story_text(paras, 0)
@@ -990,6 +1008,7 @@ with gr.Blocks(title="MomsVoice", css=css_code) as demo:
 
     # 8. Ask button — PAUSED-ASKING state
     def enter_asking_state():
+        cancel_pregeneration()
         status_html = """
             <div style="margin-top: 12px; display: flex; align-items: center; gap: 10px; justify-content: center;">
                 <span style="width: 8px; height: 8px; border-radius: 50%; background: #f59e0b; display: inline-block; animation: pulse 1s infinite;"></span>
@@ -1031,6 +1050,8 @@ with gr.Blocks(title="MomsVoice", css=css_code) as demo:
             answer_fn=answer_question_audio,
             max_new_tokens=100,
         )
+        if has_audio and result.get("error"):
+            release_audio_submission(question_audio_path)
 
         if not result["ok"]:
             answer_html = """

inference_lfm.py

@@ -5,6 +5,7 @@ Replaces the 3-model pipeline (Whisper ASR + Qwen Q&A + Qwen TTS) with a single
 multimodal model that accepts audio/text input and produces audio+text output.
 """
 import logging
+import threading
 import torch
 import numpy as np
 
@@ -14,21 +15,72 @@ logger = logging.getLogger(__name__)
 
 _processor = None
 _model = None
+_model_lock = threading.Lock()
 
 HF_REPO = "LiquidAI/LFM2.5-Audio-1.5B"
 SAMPLE_RATE = 24000
 
 
+def _select_device() -> torch.device:
+    return torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+
+def _select_dtype() -> torch.dtype:
+    if not torch.cuda.is_available():
+        return torch.float32
+    cap = torch.cuda.get_device_capability()
+    return torch.bfloat16 if cap[0] >= 8 else torch.float16
+
+
+def _move_module(module, device: torch.device, dtype: torch.dtype):
+    if not hasattr(module, "to"):
+        return module
+    try:
+        return module.to(device=device, dtype=dtype)
+    except TypeError:
+        try:
+            return module.to(device)
+        except Exception:
+            return module
+    except Exception:
+        return module
+
+
+def _module_device(module, fallback: torch.device) -> torch.device:
+    try:
+        return next(module.parameters()).device
+    except Exception:
+        return getattr(module, "device", fallback)
+
+
 def get_lfm_model():
     """Load LFM2.5-Audio-1.5B model. Cached after first call."""
     global _processor, _model
     if _model is None:
-        from liquid_audio import LFM2AudioModel, LFM2AudioProcessor
-
-        logger.info("Loading %s...", HF_REPO)
-        _processor = LFM2AudioProcessor.from_pretrained(HF_REPO).eval()
-        _model = LFM2AudioModel.from_pretrained(HF_REPO).eval()
-        logger.info("LFM2.5-Audio loaded.")
+        with _model_lock:
+            if _model is None:
+                from liquid_audio import LFM2AudioModel, LFM2AudioProcessor
+
+                device = _select_device()
+                dtype = _select_dtype()
+                logger.info("Loading %s on %s (%s)...", HF_REPO, device, dtype)
+                _processor = LFM2AudioProcessor.from_pretrained(HF_REPO).eval()
+                try:
+                    _model = LFM2AudioModel.from_pretrained(
+                        HF_REPO,
+                        torch_dtype=dtype if device.type == "cuda" else torch.float32,
+                    ).eval()
+                except TypeError:
+                    _model = LFM2AudioModel.from_pretrained(HF_REPO).eval()
+
+                moved_processor = _move_module(_processor, device, dtype)
+                if moved_processor is not None:
+                    _processor = moved_processor
+                moved_model = _move_module(_model, device, dtype)
+                if moved_model is not None:
+                    _model = moved_model
+                _model = _model.eval()
+                logger.info("LFM2.5-Audio loaded on %s.", _module_device(_model, device))
     return _processor, _model
 
 
@@ -66,7 +118,7 @@ def answer_question_audio(
     if question_audio_path:
         import librosa
         wav_np, sr = librosa.load(question_audio_path, sr=16000, mono=True)
-        wav = torch.from_numpy(wav_np).unsqueeze(0)  # (1, samples)
+        wav = torch.from_numpy(wav_np).unsqueeze(0).to(_module_device(model, _select_device()))
         sr = 16000
         chat.add_audio(wav, sr)
     elif question_text:
@@ -95,12 +147,13 @@ def answer_question_audio(
     # Decode text
     answer_text = ""
     if text_out:
-        answer_text = "".join(processor.text.decode(t) for t in text_out).strip()
+        answer_text = "".join(processor.text.decode(t.detach().cpu()) for t in text_out).strip()
 
     # Decode audio
     waveform = None
     if audio_out and len(audio_out) > 1:
-        audio_codes = torch.stack(audio_out[:-1], 1).unsqueeze(0)
+        decode_device = _module_device(processor, _module_device(model, _select_device()))
+        audio_codes = torch.stack(audio_out[:-1], 1).unsqueeze(0).to(decode_device)
         with GPU_INFERENCE_LOCK, torch.inference_mode():
             waveform_tensor = processor.decode(audio_codes)
         waveform = waveform_tensor.cpu().numpy().squeeze()

qa_flow.py

@@ -2,6 +2,7 @@
 from __future__ import annotations
 
 import logging
+import os
 import threading
 import time
 import uuid
@@ -14,6 +15,7 @@ DEFAULT_SAMPLE_RATE = 24000
 _RECENT_AUDIO_LOCK = threading.Lock()
 _RECENT_AUDIO_SUBMISSIONS: dict[str, float] = {}
 _DUPLICATE_WINDOW_SEC = 30.0
+_GENERATED_QA_MAX_FILES = int(os.environ.get("MOMSVOICE_QA_AUDIO_MAX_FILES", "30"))
 
 
 class AudioWriter(Protocol):
@@ -55,12 +57,38 @@ def claim_audio_submission(audio_path: str | Path | None) -> bool:
         return True
 
 
+def release_audio_submission(audio_path: str | Path | None) -> None:
+    """Allow a recording to be submitted again, used after failed generation."""
+    normalized = _normalize_audio_path(audio_path)
+    if not normalized:
+        return
+    with _RECENT_AUDIO_LOCK:
+        _RECENT_AUDIO_SUBMISSIONS.pop(normalized, None)
+
+
 def _default_audio_writer(path: Path, waveform, sample_rate: int) -> None:
     import soundfile as sf
 
     sf.write(str(path), waveform, sample_rate)
 
 
+def _prune_generated_answers(output_dir: Path) -> None:
+    try:
+        files = sorted(
+            output_dir.glob("qa_answer_*.wav"),
+            key=lambda path: path.stat().st_mtime,
+            reverse=True,
+        )
+    except OSError:
+        return
+
+    for stale in files[_GENERATED_QA_MAX_FILES:]:
+        try:
+            stale.unlink()
+        except OSError:
+            continue
+
+
 def build_qa_response(
     *,
     question_text: str | None,
@@ -86,6 +114,7 @@ def build_qa_response(
         }
 
     story_context = "\n\n".join(paragraphs or [])
+    error = None
     try:
         answer_text, waveform, sr = answer_fn(
             question_audio_path=audio_path if has_audio else None,
@@ -97,6 +126,7 @@ def build_qa_response(
             answer_text = "Hmm, I'm not sure about that! Let's keep listening to find out."
     except Exception as exc:
         logger.exception("LFM Q&A failed: %s", exc)
+        error = type(exc).__name__
         answer_text = (
             "Oops, I couldn't think of an answer right now. Let's keep reading! "
             f"({type(exc).__name__})"
@@ -108,12 +138,18 @@ def build_qa_response(
     if waveform is not None:
         output_dir.mkdir(parents=True, exist_ok=True)
         answer_audio_path = output_dir / f"qa_answer_{uuid.uuid4().hex[:8]}.wav"
-        audio_writer(answer_audio_path, waveform, sr)
+        try:
+            audio_writer(answer_audio_path, waveform, sr)
+            _prune_generated_answers(output_dir)
+        except Exception as exc:
+            logger.exception("Failed to write answer audio: %s", exc)
+            error = error or type(exc).__name__
+            answer_audio_path = None
 
     return {
         "ok": True,
         "answer_text": answer_text,
         "display_question": q_txt or "(audio question)",
         "audio_path": answer_audio_path,
-        "error": None,
+        "error": error,
     }

test_modules/test_qa_flow.py

@@ -1,11 +1,13 @@
 """Dependency-light tests for the Ask/Q&A server flow."""
+import logging
 import tempfile
 import sys
 from pathlib import Path
 
 sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+logging.disable(logging.CRITICAL)
 
-from qa_flow import build_qa_response, claim_audio_submission
+from qa_flow import build_qa_response, claim_audio_submission, release_audio_submission
 
 
 def check(label, condition):
@@ -27,6 +29,10 @@ def fake_writer(path: Path, waveform, sample_rate: int):
     path.write_bytes(b"RIFF fake wav")
 
 
+def failing_answer_fn(**kwargs):
+    raise RuntimeError("model unavailable")
+
+
 def test_empty_question():
     result = build_qa_response(
         question_text="",
@@ -75,6 +81,21 @@ def test_duplicate_audio_claim():
         audio = Path(tmp) / "same-question.wav"
         check("first audio claim accepted", claim_audio_submission(audio) is True)
         check("duplicate audio claim rejected", claim_audio_submission(audio) is False)
+        release_audio_submission(audio)
+        check("released audio claim can retry", claim_audio_submission(audio) is True)
+
+
+def test_failed_answer_marks_error():
+    result = build_qa_response(
+        question_text="",
+        question_audio_path="question.wav",
+        paragraphs=["The Three Little Pigs met a wolf."],
+        output_dir=Path(tempfile.gettempdir()),
+        answer_fn=failing_answer_fn,
+    )
+    check("failed answer still returns display result", result["ok"] is True)
+    check("failed answer records error", result["error"] == "RuntimeError")
+    check("failed answer has no audio", result["audio_path"] is None)
 
 
 if __name__ == "__main__":
@@ -82,4 +103,5 @@ if __name__ == "__main__":
     test_text_question()
     test_audio_question_writes_answer()
     test_duplicate_audio_claim()
+    test_failed_answer_marks_error()
     print("Q&A flow tests passed")

test_modules/test_tts_pregen.py

@@ -0,0 +1,202 @@
+"""Dependency-light tests for TTS pregeneration behavior."""
+import os
+import logging
+import sys
+import tempfile
+import time
+import types
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+logging.disable(logging.CRITICAL)
+
+
+class FakeArray(list):
+    def __mul__(self, value):
+        if isinstance(value, list):
+            return FakeArray(a * b for a, b in zip(self, value))
+        return FakeArray(item * value for item in self)
+
+    __rmul__ = __mul__
+
+
+def install_dependency_stubs():
+    try:
+        import numpy as real_np  # noqa: F401
+    except ModuleNotFoundError:
+        fake_np = types.ModuleType("numpy")
+        fake_np.ndarray = FakeArray
+        fake_np.float32 = float
+        fake_np.pi = 3.141592653589793
+        fake_np.ones = lambda n, dtype=None: FakeArray([1.0] * n)
+        fake_np.zeros = lambda n, dtype=None: FakeArray([0.0] * n)
+        fake_np.linspace = lambda start, stop, num, dtype=None: FakeArray(
+            [start + (stop - start) * i / max(num - 1, 1) for i in range(num)]
+        )
+        fake_np.sin = lambda values: FakeArray(
+            __import__("math").sin(value) for value in values
+        )
+        fake_np.concatenate = lambda arrays: FakeArray(
+            item for array in arrays for item in array
+        )
+        sys.modules["numpy"] = fake_np
+
+    try:
+        import soundfile as real_sf  # noqa: F401
+    except ModuleNotFoundError:
+        fake_sf = types.ModuleType("soundfile")
+        audio_store = {}
+
+        def write(path, waveform, sample_rate):
+            audio_store[str(path)] = (waveform, sample_rate)
+            Path(path).write_bytes(b"RIFF fake wav")
+
+        def read(path, dtype="float32"):
+            waveform, sample_rate = audio_store[str(path)]
+            return waveform, sample_rate
+
+        fake_sf.write = write
+        fake_sf.read = read
+        sys.modules["soundfile"] = fake_sf
+
+
+install_dependency_stubs()
+
+import numpy as np  # noqa: E402
+import tts  # noqa: E402
+
+
+PASS = 0
+FAIL = 0
+
+
+def check(label, condition, detail=""):
+    global PASS, FAIL
+    if condition:
+        PASS += 1
+        print(f"[OK] {label}")
+    else:
+        FAIL += 1
+        print(f"[FAIL] {label} -- {detail}")
+
+
+def wait_for_pregen(chunks, profile_id=None, timeout=2.0):
+    deadline = time.time() + timeout
+    status = tts.get_pregeneration_status(chunks, profile_id)
+    while status.get("in_progress") and time.time() < deadline:
+        time.sleep(0.02)
+        status = tts.get_pregeneration_status(chunks, profile_id)
+    return status
+
+
+def reset_pregen_state():
+    tts.cancel_pregeneration()
+    with tts._pregen_lock:
+        tts._pregen_cache.clear()
+        tts._pregen_in_progress.clear()
+        tts._pregen_progress.clear()
+        tts._pregen_cancel_events.clear()
+
+
+def run_with_temp_cache(test_fn):
+    original_cache_dir = tts._CACHE_DIR
+    original_synth = tts._synthesize_single
+    with tempfile.TemporaryDirectory() as tmp:
+        tts._CACHE_DIR = tmp
+        os.makedirs(tts._CACHE_DIR, exist_ok=True)
+        reset_pregen_state()
+        try:
+            test_fn()
+        finally:
+            reset_pregen_state()
+            tts._CACHE_DIR = original_cache_dir
+            tts._synthesize_single = original_synth
+
+
+def test_pregen_limits_initial_chunks():
+    calls = []
+
+    def fake_synth(chunk, profile_id):
+        calls.append(chunk)
+        return np.ones(8, dtype=np.float32), 24000
+
+    tts._synthesize_single = fake_synth
+    chunks = ["one", "two", "three", "four", "five"]
+    tts.pregenerate_story_audio(chunks, voice_profile_id="voice-a", max_chunks=2)
+    status = wait_for_pregen(chunks, "voice-a")
+
+    check("pregen targets requested initial chunks", status.get("target") == 2, status)
+    check("pregen synthesized only initial chunks", calls == chunks[:2], calls)
+    check("partial pregen is not marked complete", status.get("complete") is False, status)
+    check("partial pregen records cached count", status.get("cached") == 2, status)
+
+
+def test_pregen_failure_records_error():
+    def fake_synth(chunk, profile_id):
+        if chunk == "bad":
+            raise RuntimeError("boom")
+        return np.ones(8, dtype=np.float32), 24000
+
+    tts._synthesize_single = fake_synth
+    chunks = ["ok", "bad", "later"]
+    tts.pregenerate_story_audio(chunks, voice_profile_id="voice-b", max_chunks=3)
+    status = wait_for_pregen(chunks, "voice-b")
+
+    check("failed pregen records error", status.get("errors") == 1, status)
+    check("failed pregen is not complete", status.get("complete") is False, status)
+    check("failed chunk is not cached", tts._get_cached_audio("bad", "voice-b") is None)
+
+
+def test_cancel_stops_waiting_pregen():
+    calls = []
+
+    def fake_synth(chunk, profile_id):
+        calls.append(chunk)
+        return np.ones(8, dtype=np.float32), 24000
+
+    tts._synthesize_single = fake_synth
+    chunks = ["slow-one", "slow-two"]
+    tts.GPU_INFERENCE_LOCK.acquire()
+    try:
+        tts.pregenerate_story_audio(chunks, voice_profile_id="voice-c", max_chunks=2)
+        time.sleep(0.05)
+        tts.cancel_pregeneration()
+    finally:
+        tts.GPU_INFERENCE_LOCK.release()
+
+    status = wait_for_pregen(chunks, "voice-c")
+    time.sleep(0.05)
+    check("cancel marks pregen cancelled", status.get("cancelled") is True, status)
+    check("cancelled pregen does not synthesize queued chunks", calls == [], calls)
+
+
+def test_progress_metadata_is_bounded():
+    original_limit = tts._PREGEN_PROGRESS_MAX_STORIES
+    tts._PREGEN_PROGRESS_MAX_STORIES = 2
+    try:
+        with tts._pregen_lock:
+            for idx in range(5):
+                tts._pregen_progress[f"story-{idx}"] = {
+                    "cached": 0,
+                    "total": 1,
+                    "target": 1,
+                    "in_progress": False,
+                    "complete": False,
+                    "errors": 0,
+                    "cancelled": False,
+                }
+            tts._prune_pregen_progress_locked()
+            keys = list(tts._pregen_progress)
+        check("pregen progress metadata is bounded", len(keys) == 2, keys)
+        check("pregen progress keeps newest records", keys == ["story-3", "story-4"], keys)
+    finally:
+        tts._PREGEN_PROGRESS_MAX_STORIES = original_limit
+
+
+if __name__ == "__main__":
+    run_with_temp_cache(test_pregen_limits_initial_chunks)
+    run_with_temp_cache(test_pregen_failure_records_error)
+    run_with_temp_cache(test_cancel_stops_waiting_pregen)
+    run_with_temp_cache(test_progress_metadata_is_bounded)
+    print(f"TTS pregen tests: {PASS} passed, {FAIL} failed")
+    sys.exit(1 if FAIL else 0)

tts.py

@@ -22,11 +22,12 @@ import os
 import queue
 import re
 import threading
+from collections import OrderedDict
 
 import numpy as np
 import soundfile as sf
 
-from runtime_config import AUDIO_CACHE_DIR
+from runtime_config import AUDIO_CACHE_DIR, GPU_INFERENCE_LOCK
 
 logger = logging.getLogger(__name__)
 
@@ -49,9 +50,17 @@ _TRANSITION_CHIME = 0.08 * np.sin(2 * np.pi * 440 * _chime_t) * np.linspace(1, 0
 
 # Background pre-generation state
 _pregen_lock = threading.Lock()
-_pregen_cache: dict[str, list[tuple[int, np.ndarray]]] = {}  # key -> [(sr, wav), ...]
+_pregen_cache: OrderedDict[str, list[tuple[int, np.ndarray]]] = OrderedDict()
 _pregen_in_progress: set[str] = set()
 _pregen_progress: dict[str, dict[str, int | bool]] = {}
+_pregen_cancel_events: dict[str, threading.Event] = {}
+
+# Keep background work small so live Ask/playback can take the GPU quickly.
+_PREGEN_CHUNK_LIMIT = int(os.environ.get("MOMSVOICE_PREGEN_CHUNKS", "3"))
+_PREGEN_CACHE_MAX_STORIES = int(os.environ.get("MOMSVOICE_PREGEN_CACHE_STORIES", "4"))
+_PREGEN_PROGRESS_MAX_STORIES = int(os.environ.get("MOMSVOICE_PREGEN_PROGRESS_STORIES", "16"))
+_AUDIO_CACHE_MAX_FILES = int(os.environ.get("MOMSVOICE_AUDIO_CACHE_MAX_FILES", "400"))
+_AUDIO_CACHE_MAX_BYTES = int(os.environ.get("MOMSVOICE_AUDIO_CACHE_MAX_BYTES", str(512 * 1024 * 1024)))
 
 
 def _cache_key(text: str, voice_profile_id: str | None) -> str:
@@ -64,6 +73,34 @@ def _story_key(chunks: list[str], voice_profile_id: str | None) -> str:
     return _cache_key("\n".join(chunks), voice_profile_id)
 
 
+def _prune_pregen_progress_locked() -> None:
+    removable = [
+        story_key for story_key, progress in _pregen_progress.items()
+        if story_key not in _pregen_in_progress and not progress.get("in_progress")
+    ]
+    while len(_pregen_progress) > _PREGEN_PROGRESS_MAX_STORIES and removable:
+        _pregen_progress.pop(removable.pop(0), None)
+
+
+def cancel_pregeneration() -> None:
+    """Ask all background pre-generation workers to stop after their current chunk."""
+    with _pregen_lock:
+        for event in _pregen_cancel_events.values():
+            event.set()
+        for story_key in list(_pregen_in_progress):
+            progress = _pregen_progress.get(story_key)
+            if progress is not None:
+                progress["in_progress"] = False
+                progress["cancelled"] = True
+        _pregen_in_progress.clear()
+        _prune_pregen_progress_locked()
+
+
+def _prune_pregen_cache_locked() -> None:
+    while len(_pregen_cache) > _PREGEN_CACHE_MAX_STORIES:
+        _pregen_cache.popitem(last=False)
+
+
 def get_pregeneration_status(
     chunks: list[str],
     voice_profile_id: str | None = None,
@@ -76,25 +113,33 @@ def get_pregeneration_status(
     story_key = _story_key(chunks, voice_profile_id)
     with _pregen_lock:
         if story_key in _pregen_cache:
+            _pregen_cache.move_to_end(story_key)
             return {
                 "cached": len(_pregen_cache[story_key]),
                 "total": total,
+                "target": total,
                 "in_progress": False,
                 "complete": True,
+                "errors": 0,
+                "cancelled": False,
             }
         progress = _pregen_progress.get(story_key)
         if progress is not None:
             return dict(progress)
 
+    target = min(total, _PREGEN_CHUNK_LIMIT)
     cached = sum(
-        1 for chunk in chunks
+        1 for chunk in chunks[:target]
         if _get_cached_audio(chunk, voice_profile_id) is not None
     )
     return {
         "cached": cached,
         "total": total,
+        "target": target,
         "in_progress": False,
         "complete": cached == total,
+        "errors": 0,
+        "cancelled": False,
     }
 
 
@@ -117,10 +162,40 @@ def _save_cached_audio(chunk_text: str, voice_profile_id: str | None, wav: np.nd
     path = os.path.join(_CACHE_DIR, f"{key}.wav")
     try:
         sf.write(path, wav, sr)
+        _prune_audio_cache()
     except Exception:
         pass
 
 
+def _prune_audio_cache():
+    """Bound disk cache by deleting oldest cached audio files."""
+    try:
+        entries = [
+            entry for entry in os.scandir(_CACHE_DIR)
+            if entry.is_file() and entry.name.endswith(".wav")
+        ]
+        total_bytes = sum(entry.stat().st_size for entry in entries)
+        if len(entries) <= _AUDIO_CACHE_MAX_FILES and total_bytes <= _AUDIO_CACHE_MAX_BYTES:
+            return
+
+        entries.sort(key=lambda entry: entry.stat().st_mtime)
+        idx = 0
+        while idx < len(entries):
+            if len(entries) <= _AUDIO_CACHE_MAX_FILES and total_bytes <= _AUDIO_CACHE_MAX_BYTES:
+                break
+            entry = entries[idx]
+            try:
+                size = entry.stat().st_size
+                os.remove(entry.path)
+                total_bytes -= size
+                entries.pop(idx)
+            except OSError:
+                idx += 1
+                continue
+    except OSError:
+        return
+
+
 def split_into_chunks(text: str) -> list[str]:
     """Split text into short chunks suitable for low-latency TTS streaming.
     
@@ -154,57 +229,101 @@ def split_into_chunks(text: str) -> list[str]:
     return [c for c in chunks if c]
 
 
-def pregenerate_story_audio(chunks: list[str], voice_profile_id: str | None = None):
-    """Pre-generate all story audio in background. Results cached for instant playback.
+def pregenerate_story_audio(
+    chunks: list[str],
+    voice_profile_id: str | None = None,
+    max_chunks: int = _PREGEN_CHUNK_LIMIT,
+):
+    """Pre-generate the first few story chunks in background.
     
-    Call this on book selection to pre-warm the cache. Non-blocking.
+    Call this on book selection to pre-warm initial playback. Non-blocking.
     """
     story_key = _story_key(chunks, voice_profile_id)
+    target_chunks = chunks[:max(0, min(len(chunks), max_chunks))]
+    target = len(target_chunks)
+    if target == 0:
+        return
     
     with _pregen_lock:
         if story_key in _pregen_in_progress or story_key in _pregen_cache:
             return  # Already running or done
+        cancel_event = threading.Event()
         _pregen_in_progress.add(story_key)
+        _pregen_cancel_events[story_key] = cancel_event
         _pregen_progress[story_key] = {
             "cached": 0,
             "total": len(chunks),
+            "target": target,
             "in_progress": True,
             "complete": False,
+            "errors": 0,
+            "cancelled": False,
         }
 
     def _worker():
         results = []
+        errors = 0
         sr = 24000
-        for i, chunk in enumerate(chunks):
+        for i, chunk in enumerate(target_chunks):
+            if cancel_event.is_set():
+                break
             # Check disk cache first
             cached = _get_cached_audio(chunk, voice_profile_id)
             if cached is not None:
                 results.append((sr, cached))
                 with _pregen_lock:
-                    _pregen_progress[story_key]["cached"] = len(results)
+                    if _pregen_cancel_events.get(story_key) is cancel_event:
+                        _pregen_progress[story_key]["cached"] = len(results)
                 continue
             # Synthesize
             try:
-                wav, sample_rate = _synthesize_single(chunk, voice_profile_id)
+                acquired = False
+                while not cancel_event.is_set():
+                    acquired = GPU_INFERENCE_LOCK.acquire(timeout=0.1)
+                    if acquired:
+                        break
+                if not acquired or cancel_event.is_set():
+                    break
+                try:
+                    wav, sample_rate = _synthesize_single(chunk, voice_profile_id)
+                finally:
+                    GPU_INFERENCE_LOCK.release()
                 sr = sample_rate
                 results.append((sr, wav))
                 _save_cached_audio(chunk, voice_profile_id, wav, sr)
             except Exception as e:
+                errors += 1
                 logger.warning("Pre-gen failed on chunk %d: %s", i, e)
-                results.append((sr, np.zeros(0, dtype=np.float32)))
             with _pregen_lock:
-                _pregen_progress[story_key]["cached"] = len(results)
+                if _pregen_cancel_events.get(story_key) is cancel_event:
+                    _pregen_progress[story_key]["cached"] = len(results)
+                    _pregen_progress[story_key]["errors"] = errors
         
         with _pregen_lock:
-            _pregen_cache[story_key] = results
+            if _pregen_cancel_events.get(story_key) is not cancel_event:
+                return
+            cancelled = cancel_event.is_set()
+            fully_cached = len(results) == len(chunks) and errors == 0 and not cancelled
+            if fully_cached:
+                _pregen_cache[story_key] = results
+                _pregen_cache.move_to_end(story_key)
+                _prune_pregen_cache_locked()
             _pregen_progress[story_key] = {
                 "cached": len(results),
                 "total": len(chunks),
+                "target": target,
                 "in_progress": False,
-                "complete": True,
+                "complete": fully_cached,
+                "errors": errors,
+                "cancelled": cancelled,
             }
             _pregen_in_progress.discard(story_key)
-        logger.info("Pre-generation complete: %d chunks cached.", len(chunks))
+            _pregen_cancel_events.pop(story_key, None)
+            _prune_pregen_progress_locked()
+        logger.info(
+            "Pre-generation finished: %d/%d initial chunks cached (errors=%d, cancelled=%s).",
+            len(results), target, errors, cancelled,
+        )
 
     threading.Thread(target=_worker, daemon=True).start()