Show quality fixes + preflight check

Ep47 post-mortem: fixed theme ignored by callers (backgrounds now
regenerate when theme is set), style-to-model race condition (fallback
to sonnet instead of pool[0]), removed bad pronunciation fixes, added
age-awareness to voice matching, raised MIN_RESPONSE_WORDS to 50.

Swapped problematic model mappings: conspiracy→qwen, know_it_all→mistral,
quiet_nervous→llama, emotional→kimi.

Added GET /api/show/preflight endpoint with 4 checks: model diversity,
theme penetration, voice-age alignment, response coherence (2-exchange
simulation of all callers). Frontend preflight modal with expandable
check cards.

Fixed active caller button not highlighting (moved highlight code before
potentially-failing caller info panel code).

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

.env.example

@@ -0,0 +1,48 @@
+# API Keys
+OPENROUTER_API_KEY=
+ELEVENLABS_API_KEY=
+INWORLD_API_KEY=
+OPENAI_API_KEY=
+
+# SignalWire (real callers)
+SIGNALWIRE_PROJECT_ID=
+SIGNALWIRE_SPACE=
+SIGNALWIRE_TOKEN=
+SIGNALWIRE_PHONE=
+SIGNALWIRE_STREAM_URL=
+
+# Social media
+TWITTER_API_KEY=
+TWITTER_API_SECRET=
+TWITTER_ACCESS_TOKEN=
+TWITTER_ACCESS_TOKEN_SECRET=
+CLIENT_SECRET_ID=
+CLIENT_SECRET=
+POSTIZ_URL=
+POSTIZ_API_KEY=
+BSKY_APP_PASSWORD=
+
+# Castopod
+CASTOPOD_USERNAME=admin
+CASTOPOD_PASSWORD=
+CASTOPOD_DB_PASS=
+
+# Postiz publishing
+POSTIZ_JWT_SECRET=
+POSTIZ_USER_ID=
+POSTIZ_INTEGRATIONS={}
+
+# BunnyCDN
+BUNNY_STORAGE_KEY=
+BUNNY_ACCOUNT_KEY=
+
+# Monitoring
+HEARTBEAT_URL=
+
+# Google AI
+GOOGLE_API_KEY=
+
+# Email (IMAP)
+SUBMISSIONS_IMAP_HOST=
+SUBMISSIONS_IMAP_USER=
+SUBMISSIONS_IMAP_PASS=

.github-last-push

@@ -0,0 +1 @@
+2c7fcdb5aecbb0d3bf039abab9e723d62bc8fe1a

.gitignore

@@ -50,5 +50,12 @@ voices-v1.0.bin
 # Reference voices for TTS
 ref_audio/
 
+# YouTube OAuth credentials
+youtube_client_secrets.json
+youtube_token.json
+
+# Clip upload history (local)
+upload-history.json
+
 # Claude settings (local)
 .claude/

CLAUDE.md

@@ -18,15 +18,14 @@
 ## Castopod (Podcast Publishing)
 - **URL**: https://podcast.macneilmediagroup.com
 - **Podcast handle**: `@LukeAtTheRoost`
-- **API Auth**: Basic auth (admin/podcast2026api)
+- **API Auth**: Basic auth (credentials in .env: CASTOPOD_USERNAME, CASTOPOD_PASSWORD)
 - **Container**: `castopod-castopod-1`
 - **Database**: `castopod-mariadb-1` (user: castopod, db: castopod)
 
 ## Running the App
 ```bash
-# Start backend
-cd /Users/lukemacneil/ai-podcast
-python -m uvicorn backend.main:app --reload --host 0.0.0.0 --port 8000
+# Start backend — ALWAYS use --reload-dir to avoid CPU thrashing from file watchers
+python -m uvicorn backend.main:app --reload --reload-dir backend --host 0.0.0.0 --port 8000
 
 # Or use run.sh
 ./run.sh
@@ -42,3 +41,71 @@ Required in `.env`:
 - OPENROUTER_API_KEY
 - ELEVENLABS_API_KEY (optional)
 - INWORLD_API_KEY (for Inworld TTS)
+
+## Post-Production Pipeline (added Feb 2026)
+- **Branch**: `feature/real-callers` — all current work is here, pushed to gitea
+- **Stem Recorder** (`backend/services/stem_recorder.py`): Records 5 WAV stems (host, caller, music, sfx, ads) during live shows. Uses lock-free deque architecture — audio callbacks just append to deques, a background writer thread drains to disk. `write()` for continuous streams (host mic, music, ads), `write_sporadic()` for burst sources (caller TTS, SFX) with time-aligned silence padding.
+- **Audio hooks** in `backend/services/audio.py`: 7 tap points guarded by `if self.stem_recorder:`. Persistent mic stream (`start_stem_mic`/`stop_stem_mic`) runs during recording to capture host voice continuously, not just during push-to-talk.
+- **API endpoints**: `POST /api/recording/start`, `POST /api/recording/stop` (auto-runs postprod in background thread), `POST /api/recording/process`
+- **Frontend**: REC button in header with red pulse animation when recording
+- **Post-prod script** (`postprod.py`): 6-step pipeline — load stems → gap removal → voice compression (ffmpeg acompressor) → music ducking → stereo mix → EBU R128 loudness normalization to -16 LUFS. All steps skippable via CLI flags.
+- **Known issues resolved**: Lock-free recorder (old version used threading.Lock in audio callbacks causing crashes), scipy.signal.resample replaced with nearest-neighbor (was producing artifacts on small chunks), sys import bug in auto-postprod, host mic not captured without persistent stream
+
+## LLM Settings
+- `_pick_response_budget()` in main.py controls caller dialog token limits (150-450 tokens). MiniMax respects limits strictly — if responses seem short, check these values.
+- Default max_tokens in llm.py is 300 (for non-caller uses)
+- Grok (`x-ai/grok-4-fast`) works well for natural dialog; MiniMax tends toward terse responses
+- `generate_with_tools()` in llm.py supports OpenRouter function calling for the intern feature
+
+## Caller Generation System
+- **CallerBackground dataclass**: Structured output from LLM background generation (JSON mode). Fields: name, age, gender, job, location, reason_for_calling, pool_name, communication_style, energy_level, emotional_state, signature_detail, situation_summary, natural_description, seeds, verbal_fluency, calling_from.
+- **Voice-personality matching**: `_match_voices_to_styles()` runs after background generation. 68 voice profiles in `VOICE_PROFILES` (tts.py), 18 style-to-voice mappings in `STYLE_VOICE_PREFERENCES` (main.py). Soft matching — scores voices against style preferences.
+- **Adaptive call shapes**: `SHAPE_STYLE_AFFINITIES` maps communication styles to shape weight multipliers. Consecutive shape repeats are dampened.
+- **Inter-caller awareness**: Thematic matching in `get_show_history()` scores previous callers by keyword/category overlap. Adaptive reaction frequency (60%/35%/15%). Show energy tracking via `_get_show_energy()`.
+- **Caller memory**: Returning callers store structured backgrounds, key moments, arc status, and relationships with other regulars. `RegularCallerService` has `add_relationship()` and expanded `update_after_call()`.
+- **Show pacing**: `_sort_caller_queue()` sorts presentation order by energy alternation, topic variety, shape variety.
+- **Call quality signals**: `_assess_call_quality()` captures exchange count, response length, host engagement, shape target hit, natural ending.
+
+## Devon (Intern Character)
+- **Service**: `backend/services/intern.py` — persistent show character, not a caller
+- **Personality**: 23-year-old NMSU grad, eager, slightly incompetent, gets yelled at. Voice: "Nate" (Inworld), no phone filter.
+- **Tools**: web_search (SearXNG), get_headlines, fetch_webpage, wikipedia_lookup — via `generate_with_tools()` function calling
+- **Endpoints**: `POST /api/intern/ask`, `/interject`, `/monitor`, `GET /api/intern/suggestion`, `POST /api/intern/suggestion/play`, `/dismiss`
+- **Auto-monitoring**: Watches conversation every 15s during calls, buffers suggestions for host approval
+- **Persistence**: `data/intern.json` stores lookup history
+- **Frontend**: Ask Devon input (D key), Interject button, monitor toggle, suggestion indicator with Play/Dismiss
+
+## Frontend Control Panel
+- **Keyboard shortcuts**: 1-0 (callers), H (hangup), W (wrap up), M (music toggle), D (ask Devon), Escape (close modals)
+- **Wrap It Up**: Amber button that signals callers to wind down gracefully. Reduces response budget, injects wrap-up signals, forces goodbye after 2 exchanges.
+- **Caller info panel**: Shows call shape, energy level, emotional state, signature detail, situation summary during active calls
+- **Caller buttons**: Energy dots (colored by level) and shape badges on each button
+- **Pinned SFX**: Cheer/Applause/Boo always visible, rest collapsible
+- **Visual polish**: Thinking pulse, call glow, compact media row, smoother transitions
+
+## Website
+- **Domain**: lukeattheroost.com (behind Cloudflare)
+- **Analytics**: Cloudflare Web Analytics (enable in Cloudflare dashboard, no code changes needed)
+- **Deploy**: `npx wrangler pages deploy website/ --project-name=lukeattheroost --branch=main`
+
+## Git Push
+- If `mmgnas` times out, use the 10g hostname:
+  ```bash
+  GIT_SSH_COMMAND="ssh -o HostName=mmgnas-10g -p 2222 -i ~/.ssh/gitea_mmgnas" git push origin main
+  ```
+
+## Hetzner VPS
+- **IP**: `46.225.164.41`
+- **SSH**: `ssh root@46.225.164.41` (uses default key `~/.ssh/id_rsa`)
+- **Specs**: 2 CPU, 4GB RAM, 38GB disk (~33GB free)
+- **Mail**: `docker-mailserver` at `/opt/mailserver/`
+- **Manage accounts**: `docker exec mailserver setup email add/del/list`
+- **Available for future services** — has headroom for lightweight containers. Not suitable for storage-heavy services (e.g. Castopod with daily episodes) without a disk upgrade or attached volume.
+
+## Podcast Workflow
+- Publishing pipeline: episodes go through Castopod, CDN, website, YouTube, and social
+- Always check Python venv is active and packages are installed before running publish scripts
+- Episode numbering must be verified against existing episodes
+
+## Episodes Published
+- Episode 6 published 2026-02-08 (podcast6.mp3, ~31 min)

LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 Luke MacNeil / MacNeil Media Group, LLC
+https://macneilmediagroup.com
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

analyze_gaps.py

@@ -0,0 +1,260 @@
+#!/usr/bin/env python3
+"""Analyze silence gaps in podcast stems to find optimal strip-silence thresholds.
+
+Usage: python analyze_gaps.py recordings/2026-03-17_235137/
+"""
+import sys
+import numpy as np
+import soundfile as sf
+from pathlib import Path
+
+BLOCK_SEC = 0.1
+SILENCE_DB = -30
+THRESHOLD = 10 ** (SILENCE_DB / 20)
+MIN_VOICE_SEC = 0.3
+
+
+def load_stem(path: Path) -> tuple[np.ndarray, int]:
+    audio, sr = sf.read(path, dtype="float32")
+    if audio.ndim > 1:
+        audio = audio[:, 0]
+    return audio, sr
+
+
+def compute_rms_blocks(audio: np.ndarray, sr: int) -> np.ndarray:
+    block_samples = int(sr * BLOCK_SEC)
+    n_blocks = len(audio) // block_samples
+    if n_blocks == 0:
+        return np.array([0.0])
+    trimmed = audio[:n_blocks * block_samples].reshape(n_blocks, block_samples)
+    return np.sqrt(np.mean(trimmed ** 2, axis=1))
+
+
+def compute_peak_blocks(audio: np.ndarray, sr: int) -> np.ndarray:
+    block_samples = int(sr * BLOCK_SEC)
+    n_blocks = len(audio) // block_samples
+    if n_blocks == 0:
+        return np.array([0.0])
+    trimmed = audio[:n_blocks * block_samples].reshape(n_blocks, block_samples)
+    return np.max(np.abs(trimmed), axis=1)
+
+
+def analyze(stems_dir: Path):
+    stems_dir = Path(stems_dir)
+    voice_stems = {}
+    for name in ["host", "devon", "caller"]:
+        path = stems_dir / f"{name}.wav"
+        if path.exists():
+            print(f"Loading {name}...", end=" ", flush=True)
+            audio, sr = load_stem(path)
+            voice_stems[name] = audio
+            print(f"{len(audio)/sr:.0f}s @ {sr}Hz")
+
+    if not voice_stems:
+        print("No voice stems found")
+        return
+
+    sr_val = sr
+    duration = max(len(a) for a in voice_stems.values()) / sr_val
+    print(f"\nTotal duration: {duration/60:.1f} min")
+
+    # Compute per-track RMS and peak blocks
+    track_rms = {}
+    track_peak = {}
+    for name, audio in voice_stems.items():
+        track_rms[name] = compute_rms_blocks(audio, sr_val)
+        track_peak[name] = compute_peak_blocks(audio, sr_val)
+
+    n_blocks = min(len(v) for v in track_peak.values())
+
+    # Detect gaps using same logic as Lua script (RMS for speaker ID, peak for silence)
+    min_voice_blocks = int(MIN_VOICE_SEC / BLOCK_SEC)
+    track_names = list(voice_stems.keys())
+
+    gaps = []
+    in_silence = False
+    silence_start = 0
+    track_before = None
+    last_active = None
+    voice_run = 0
+    voice_run_track = None
+
+    for i in range(n_blocks):
+        # Peak for silence detection
+        best_peak = max(track_peak[name][i] for name in track_names)
+        # RMS for speaker identification
+        best_rms = 0
+        best_track = None
+        for name in track_names:
+            r = track_rms[name][i]
+            if r > best_rms:
+                best_rms = r
+                best_track = name
+
+        all_silent = best_peak < THRESHOLD
+
+        if not all_silent:
+            last_active = best_track
+
+        if in_silence:
+            if all_silent:
+                voice_run = 0
+                voice_run_track = None
+            else:
+                if voice_run == 0:
+                    voice_run_track = best_track
+                voice_run += 1
+                if voice_run >= min_voice_blocks:
+                    voice_start_block = i - (voice_run - 1)
+                    gap_start = silence_start * BLOCK_SEC
+                    gap_end = voice_start_block * BLOCK_SEC
+                    dur = gap_end - gap_start
+                    if dur >= 0.5:  # log gaps >= 0.5s
+                        gaps.append({
+                            "start": gap_start,
+                            "end": gap_end,
+                            "dur": dur,
+                            "before": track_before or "?",
+                            "after": voice_run_track or "?",
+                        })
+                    in_silence = False
+                    voice_run = 0
+                    voice_run_track = None
+        else:
+            if all_silent:
+                in_silence = True
+                silence_start = i
+                track_before = last_active
+                voice_run = 0
+                voice_run_track = None
+
+    # Trailing silence
+    if in_silence:
+        dur = (n_blocks - silence_start) * BLOCK_SEC
+        if dur >= 0.5:
+            gaps.append({
+                "start": silence_start * BLOCK_SEC,
+                "end": n_blocks * BLOCK_SEC,
+                "dur": dur,
+                "before": track_before or "?",
+                "after": "end",
+            })
+
+    if not gaps:
+        print("No gaps detected")
+        return
+
+    # Categorize gaps
+    categories = {
+        "host_self": [],      # Host -> Host
+        "host_to_caller": [], # Host -> Caller (TTS latency)
+        "caller_to_host": [], # Caller -> Host
+        "host_to_devon": [],  # Host -> Devon (TTS latency)
+        "devon_to_host": [],  # Devon -> Host
+        "caller_to_devon": [],# Caller -> Devon (interjection)
+        "devon_to_caller": [],# Devon -> Caller
+        "other": [],
+    }
+
+    for g in gaps:
+        b, a = g["before"], g["after"]
+        if b == "host" and a == "host":
+            categories["host_self"].append(g)
+        elif b == "host" and a == "caller":
+            categories["host_to_caller"].append(g)
+        elif b == "caller" and a == "host":
+            categories["caller_to_host"].append(g)
+        elif b == "host" and a == "devon":
+            categories["host_to_devon"].append(g)
+        elif b == "devon" and a == "host":
+            categories["devon_to_host"].append(g)
+        elif b == "caller" and a == "devon":
+            categories["caller_to_devon"].append(g)
+        elif b == "devon" and a == "caller":
+            categories["devon_to_caller"].append(g)
+        else:
+            categories["other"].append(g)
+
+    # Print results
+    print(f"\n{'='*70}")
+    print(f"GAP ANALYSIS — {len(gaps)} gaps detected")
+    print(f"{'='*70}")
+
+    total_silence = sum(g["dur"] for g in gaps)
+    print(f"Total silence: {total_silence:.0f}s ({total_silence/60:.1f} min)")
+    print(f"Content after removal: ~{(duration - total_silence)/60:.1f} min")
+
+    for cat_name, cat_gaps in sorted(categories.items(), key=lambda x: -len(x[1])):
+        if not cat_gaps:
+            continue
+        durs = sorted([g["dur"] for g in cat_gaps])
+        print(f"\n--- {cat_name} ({len(cat_gaps)} gaps) ---")
+        print(f"  Range: {durs[0]:.1f}s - {durs[-1]:.1f}s")
+        print(f"  Median: {np.median(durs):.1f}s  Mean: {np.mean(durs):.1f}s")
+        if len(durs) >= 5:
+            print(f"  P25: {np.percentile(durs, 25):.1f}s  P75: {np.percentile(durs, 75):.1f}s")
+
+        # Histogram
+        brackets = [(0, 1), (1, 2), (2, 3), (3, 5), (5, 8), (8, 12), (12, 18), (18, 30), (30, 60), (60, 999)]
+        print(f"  Distribution:")
+        for lo, hi in brackets:
+            count = sum(1 for d in durs if lo <= d < hi)
+            if count > 0:
+                bar = "#" * count
+                label = f"{lo}-{hi}s" if hi < 999 else f"{lo}s+"
+                print(f"    {label:>8s}: {bar} ({count})")
+
+    # Find natural clusters and suggest thresholds
+    print(f"\n{'='*70}")
+    print("SUGGESTED THRESHOLDS")
+    print(f"{'='*70}")
+
+    # For each Devon-involved category, find the gap between interjection and TTS gaps
+    devon_gaps = categories["host_to_devon"] + categories["devon_to_host"] + categories["caller_to_devon"] + categories["devon_to_caller"]
+    if devon_gaps:
+        devon_durs = sorted([g["dur"] for g in devon_gaps])
+        # Look for a natural break between short (interjection) and long (TTS) gaps
+        short = [d for d in devon_durs if d < 5]
+        long = [d for d in devon_durs if d >= 5]
+        if short and long:
+            suggested = (max(short) + min(long)) / 2
+            print(f"Devon threshold: {suggested:.1f}s  (short gaps: {len(short)} up to {max(short):.1f}s, long gaps: {len(long)} from {min(long):.1f}s)")
+        elif short:
+            print(f"Devon threshold: {max(short) + 1:.1f}s  (all gaps are short, max {max(short):.1f}s)")
+        else:
+            print(f"Devon threshold: 3.0s  (all gaps are long, min {min(long):.1f}s)")
+
+    caller_gaps = categories["host_to_caller"] + categories["caller_to_host"]
+    if caller_gaps:
+        caller_durs = sorted([g["dur"] for g in caller_gaps])
+        short = [d for d in caller_durs if d < 5]
+        long = [d for d in caller_durs if d >= 5]
+        if short and long:
+            suggested = (max(short) + min(long)) / 2
+            print(f"Caller transition threshold: {suggested:.1f}s  (short: {len(short)} up to {max(short):.1f}s, long: {len(long)} from {min(long):.1f}s)")
+        elif long:
+            print(f"Caller transition threshold: {min(long) - 1:.1f}s  (all gaps >= {min(long):.1f}s)")
+
+    host_self = categories["host_self"]
+    if host_self:
+        host_durs = sorted([g["dur"] for g in host_self])
+        short = [d for d in host_durs if d < 5]
+        long = [d for d in host_durs if d >= 5]
+        if short and long:
+            suggested = (max(short) + min(long)) / 2
+            print(f"Same-speaker threshold: {suggested:.1f}s  (short: {len(short)} up to {max(short):.1f}s, long: {len(long)} from {min(long):.1f}s)")
+        elif long:
+            print(f"Same-speaker threshold: {min(long) - 1:.1f}s  (all gaps >= {min(long):.1f}s)")
+
+    all_durs = sorted([g["dur"] for g in gaps])
+    would_cut = [d for d in all_durs if d >= 3.0]
+    print(f"\nWith current thresholds (Devon=3s, others=6s):")
+    print(f"  Would cut: ~{len(would_cut)} gaps, ~{sum(would_cut):.0f}s ({sum(would_cut)/60:.1f} min)")
+    print(f"  Result: ~{(duration - sum(would_cut))/60:.1f} min")
+
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        print("Usage: python analyze_gaps.py <stems_dir>")
+        sys.exit(1)
+    analyze(Path(sys.argv[1]))

audio_settings.json

@@ -1,9 +1,17 @@
 {
   "input_device": 13,
+  "input_device_name": "Babyface Pro (70793771)",
   "input_channel": 1,
-  "output_device": 13,
+  "output_device": 12,
+  "output_device_name": "Radio Voice Mic",
   "caller_channel": 3,
+  "live_caller_channel": 9,
   "music_channel": 5,
   "sfx_channel": 7,
+  "ad_channel": 11,
+  "ident_channel": 15,
+  "monitor_device": null,
+  "monitor_device_name": null,
+  "monitor_channel": 1,
   "phone_filter": false
 }

backend/config.py

@@ -15,14 +15,38 @@ class Settings(BaseSettings):
     openrouter_api_key: str = os.getenv("OPENROUTER_API_KEY", "")
     inworld_api_key: str = os.getenv("INWORLD_API_KEY", "")
 
+    # SignalWire
+    signalwire_project_id: str = os.getenv("SIGNALWIRE_PROJECT_ID", "")
+    signalwire_space: str = os.getenv("SIGNALWIRE_SPACE", "")
+    signalwire_token: str = os.getenv("SIGNALWIRE_TOKEN", "")
+    signalwire_phone: str = os.getenv("SIGNALWIRE_PHONE", "")
+    signalwire_stream_url: str = os.getenv("SIGNALWIRE_STREAM_URL", "")
+
+    # Email (IMAP)
+    submissions_imap_host: str = os.getenv("SUBMISSIONS_IMAP_HOST", "")
+    submissions_imap_user: str = os.getenv("SUBMISSIONS_IMAP_USER", "")
+    submissions_imap_pass: str = os.getenv("SUBMISSIONS_IMAP_PASS", "")
+
     # LLM Settings
     llm_provider: str = "openrouter"  # "openrouter" or "ollama"
-    openrouter_model: str = "anthropic/claude-3-haiku"
+    openrouter_model: str = "anthropic/claude-sonnet-4.6"  # primary/default model
     ollama_model: str = "llama3.2"
     ollama_host: str = "http://localhost:11434"
 
+    # Per-category model routing
+    # caller_dialog is overridden by style_matched routing (see Session.caller_model_map)
+    category_models: dict = {
+        "caller_dialog": "x-ai/grok-4.1-fast",               # fallback if style_matched disabled ($0.20/$0.50)
+        "devon_ask": "x-ai/grok-4.1-fast",                   # Devon matches show energy, cheap ($0.20/$0.50)
+        "devon_monitor": "google/gemini-2.5-flash",          # just yes/no decisions, keep cheap ($0.15/$0.60)
+        "background_gen": "anthropic/claude-sonnet-4.6",       # backgrounds drive the whole call — worth the quality ($3/$15, ~$0.30/show)
+        "call_summary": "google/gemini-2.5-flash",           # post-call, no personality needed ($0.15/$0.60)
+        "news_summary": "google/gemini-2.5-flash",           # just digesting headlines ($0.15/$0.60)
+        "topic_gen": "google/gemini-2.5-flash",              # structured output ($0.15/$0.60)
+    }
+
     # TTS Settings
-    tts_provider: str = "kokoro"  # "kokoro", "elevenlabs", "vits", or "bark"
+    tts_provider: str = "inworld"  # "kokoro", "elevenlabs", "inworld", "vits", or "bark"
 
     # Audio Settings
     sample_rate: int = 24000
@@ -31,6 +55,8 @@ class Settings(BaseSettings):
     base_dir: Path = Path(__file__).parent.parent
     sounds_dir: Path = base_dir / "sounds"
     music_dir: Path = base_dir / "music"
+    ads_dir: Path = base_dir / "ads"
+    idents_dir: Path = base_dir / "idents"
     sessions_dir: Path = base_dir / "sessions"
 
     class Config:

backend/services/avatars.py

@@ -0,0 +1,96 @@
+"""Avatar service — fetches deterministic face photos from randomuser.me"""
+
+import asyncio
+from pathlib import Path
+
+import httpx
+
+AVATAR_DIR = Path(__file__).parent.parent.parent / "data" / "avatars"
+
+
+class AvatarService:
+    def __init__(self):
+        self._client: httpx.AsyncClient | None = None
+        AVATAR_DIR.mkdir(parents=True, exist_ok=True)
+
+    @property
+    def client(self) -> httpx.AsyncClient:
+        if self._client is None or self._client.is_closed:
+            self._client = httpx.AsyncClient(timeout=10.0)
+        return self._client
+
+    def get_path(self, name: str) -> Path | None:
+        path = AVATAR_DIR / f"{name}.jpg"
+        return path if path.exists() else None
+
+    async def get_or_fetch(self, name: str, gender: str = "male") -> Path:
+        """Get cached avatar or fetch from randomuser.me. Returns file path."""
+        g = "female" if gender.lower().startswith("f") else "male"
+        path = AVATAR_DIR / f"{name}.jpg"
+        # Check for gender mismatch marker — re-fetch if gender changed
+        marker = AVATAR_DIR / f"{name}.gender"
+        if path.exists():
+            cached_gender = marker.read_text().strip() if marker.exists() else None
+            if cached_gender == g:
+                return path
+            # Gender mismatch or no marker — re-fetch
+            path.unlink(missing_ok=True)
+
+        try:
+            seed = f"{name.lower().replace(' ', '_')}_{g}"
+            resp = await self.client.get(
+                "https://randomuser.me/api/",
+                params={"gender": g, "seed": seed},
+                timeout=8.0,
+            )
+            resp.raise_for_status()
+            data = resp.json()
+            photo_url = data["results"][0]["picture"]["large"]
+
+            photo_resp = await self.client.get(photo_url, timeout=8.0)
+            photo_resp.raise_for_status()
+
+            path.write_bytes(photo_resp.content)
+            marker.write_text(g)
+            print(f"[Avatar] Fetched avatar for {name} ({g})")
+            return path
+        except Exception as e:
+            print(f"[Avatar] Failed to fetch for {name}: {e}")
+            raise
+
+    async def prefetch_batch(self, callers: list[dict]):
+        """Fetch avatars for multiple callers in parallel.
+        Each dict should have 'name' and 'gender' keys."""
+        tasks = []
+        for caller in callers:
+            name = caller.get("name", "")
+            gender = caller.get("gender", "male")
+            if not name:
+                continue
+            g = "female" if gender.lower().startswith("f") else "male"
+            path = AVATAR_DIR / f"{name}.jpg"
+            marker = AVATAR_DIR / f"{name}.gender"
+            # Always call get_or_fetch if: no file, no gender marker, or gender mismatch
+            if not path.exists() or not marker.exists() or marker.read_text().strip() != g:
+                if path.exists():
+                    print(f"[Avatar] Gender mismatch for {name}: cached={marker.read_text().strip() if marker.exists() else '?'}, want={g} — re-fetching")
+                tasks.append(self.get_or_fetch(name, gender))
+
+        if not tasks:
+            return
+
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+        fetched = sum(1 for r in results if not isinstance(r, Exception))
+        failed = sum(1 for r in results if isinstance(r, Exception))
+        if fetched:
+            print(f"[Avatar] Pre-fetched {fetched} avatars{f', {failed} failed' if failed else ''}")
+
+    async def ensure_devon(self):
+        """Pre-fetch Devon's avatar on startup."""
+        try:
+            await self.get_or_fetch("Devon", "male")
+        except Exception:
+            pass
+
+
+avatar_service = AvatarService()

backend/services/caller_service.py

@@ -0,0 +1,296 @@
+"""Phone caller queue and audio stream service"""
+
+import asyncio
+import base64
+import json
+import time
+import threading
+import numpy as np
+from typing import Optional
+
+
+class CallerService:
+    """Manages phone caller queue, channel allocation, and WebSocket streams"""
+
+    FIRST_REAL_CHANNEL = 3
+
+    def __init__(self):
+        self._queue: list[dict] = []
+        self.active_calls: dict[str, dict] = {}
+        self._allocated_channels: set[int] = set()
+        self._caller_counter: int = 0
+        self._lock = threading.Lock()
+        self._websockets: dict[str, any] = {}  # caller_id -> WebSocket
+        self._call_sids: dict[str, str] = {}  # caller_id -> SignalWire callSid
+        self._stream_sids: dict[str, str] = {}  # caller_id -> SignalWire streamSid
+        self._send_locks: dict[str, asyncio.Lock] = {}  # per-caller send lock
+        self._streaming_tts: set[str] = set()  # caller_ids currently receiving TTS
+        self._screening_state: dict[str, dict] = {}  # caller_id -> screening conversation
+
+    def _get_send_lock(self, caller_id: str) -> asyncio.Lock:
+        if caller_id not in self._send_locks:
+            self._send_locks[caller_id] = asyncio.Lock()
+        return self._send_locks[caller_id]
+
+    def is_streaming_tts(self, caller_id: str) -> bool:
+        return caller_id in self._streaming_tts
+
+    def is_streaming_tts_any(self) -> bool:
+        return len(self._streaming_tts) > 0
+
+    def add_to_queue(self, caller_id: str, phone: str):
+        with self._lock:
+            self._queue.append({
+                "caller_id": caller_id,
+                "phone": phone,
+                "queued_at": time.time(),
+            })
+        print(f"[Caller] {phone} added to queue (ID: {caller_id})")
+
+    def remove_from_queue(self, caller_id: str):
+        with self._lock:
+            self._queue = [c for c in self._queue if c["caller_id"] != caller_id]
+        print(f"[Caller] {caller_id} removed from queue")
+
+    def allocate_channel(self) -> int:
+        with self._lock:
+            ch = self.FIRST_REAL_CHANNEL
+            while ch in self._allocated_channels:
+                ch += 1
+            self._allocated_channels.add(ch)
+            return ch
+
+    def release_channel(self, channel: int):
+        with self._lock:
+            self._allocated_channels.discard(channel)
+
+    def take_call(self, caller_id: str) -> dict:
+        caller = None
+        with self._lock:
+            for c in self._queue:
+                if c["caller_id"] == caller_id:
+                    caller = c
+                    break
+            if caller:
+                self._queue = [c for c in self._queue if c["caller_id"] != caller_id]
+
+        if not caller:
+            raise ValueError(f"Caller {caller_id} not in queue")
+
+        channel = self.allocate_channel()
+        self._caller_counter += 1
+        phone = caller["phone"]
+
+        call_info = {
+            "caller_id": caller_id,
+            "phone": phone,
+            "channel": channel,
+            "started_at": time.time(),
+        }
+        self.active_calls[caller_id] = call_info
+        print(f"[Caller] {phone} taken on air — channel {channel}")
+        return call_info
+
+    def hangup(self, caller_id: str):
+        call_info = self.active_calls.pop(caller_id, None)
+        if call_info:
+            self.release_channel(call_info["channel"])
+            print(f"[Caller] {call_info['phone']} hung up — channel {call_info['channel']} released")
+        self._websockets.pop(caller_id, None)
+        self._call_sids.pop(caller_id, None)
+        self._stream_sids.pop(caller_id, None)
+        self._send_locks.pop(caller_id, None)
+        self._screening_state.pop(caller_id, None)
+
+    def reset(self):
+        with self._lock:
+            for call_info in self.active_calls.values():
+                self._allocated_channels.discard(call_info["channel"])
+            self._queue.clear()
+            self.active_calls.clear()
+            self._allocated_channels.clear()
+            self._caller_counter = 0
+            self._websockets.clear()
+            self._call_sids.clear()
+            self._stream_sids.clear()
+            self._send_locks.clear()
+            self._streaming_tts.clear()
+            self._screening_state.clear()
+        print("[Caller] Service reset")
+
+    # --- Screening ---
+
+    def start_screening(self, caller_id: str):
+        """Initialize screening state for a queued caller"""
+        self._screening_state[caller_id] = {
+            "conversation": [],
+            "caller_name": None,
+            "topic": None,
+            "status": "screening",  # screening, complete
+            "response_count": 0,
+        }
+        print(f"[Screening] Started for {caller_id}")
+
+    def get_screening_state(self, caller_id: str) -> Optional[dict]:
+        return self._screening_state.get(caller_id)
+
+    def update_screening(self, caller_id: str, caller_text: str = None,
+                         screener_text: str = None, caller_name: str = None,
+                         topic: str = None):
+        """Update screening conversation and extracted info"""
+        state = self._screening_state.get(caller_id)
+        if not state:
+            return
+        if caller_text:
+            state["conversation"].append({"role": "caller", "content": caller_text})
+            state["response_count"] += 1
+        if screener_text:
+            state["conversation"].append({"role": "screener", "content": screener_text})
+        if caller_name:
+            state["caller_name"] = caller_name
+        if topic:
+            state["topic"] = topic
+
+    def end_screening(self, caller_id: str):
+        """Mark screening as complete"""
+        state = self._screening_state.get(caller_id)
+        if state:
+            state["status"] = "complete"
+            print(f"[Screening] Complete for {caller_id}: name={state.get('caller_name')}, topic={state.get('topic')}")
+
+    def get_queue(self) -> list[dict]:
+        """Get queue with screening info enrichment"""
+        now = time.time()
+        with self._lock:
+            result = []
+            for c in self._queue:
+                entry = {
+                    "caller_id": c["caller_id"],
+                    "phone": c["phone"],
+                    "wait_time": int(now - c["queued_at"]),
+                }
+                screening = self._screening_state.get(c["caller_id"])
+                if screening:
+                    entry["screening_status"] = screening["status"]
+                    entry["caller_name"] = screening.get("caller_name")
+                    entry["screening_summary"] = screening.get("topic")
+                else:
+                    entry["screening_status"] = None
+                    entry["caller_name"] = None
+                    entry["screening_summary"] = None
+                result.append(entry)
+            return result
+
+    def register_websocket(self, caller_id: str, websocket):
+        """Register a WebSocket for a caller"""
+        self._websockets[caller_id] = websocket
+
+    def unregister_websocket(self, caller_id: str):
+        """Unregister a WebSocket"""
+        self._websockets.pop(caller_id, None)
+
+    async def send_audio_to_caller(self, caller_id: str, pcm_data: bytes, sample_rate: int):
+        """Send small audio chunk to caller via SignalWire WebSocket.
+        Encodes L16 PCM as base64 JSON per SignalWire protocol.
+        """
+        if caller_id in self._streaming_tts:
+            return  # Don't send host audio during TTS streaming
+
+        ws = self._websockets.get(caller_id)
+        if not ws:
+            return
+
+        lock = self._get_send_lock(caller_id)
+        async with lock:
+            try:
+                if sample_rate != 16000:
+                    audio = np.frombuffer(pcm_data, dtype=np.int16).astype(np.float32) / 32768.0
+                    ratio = 16000 / sample_rate
+                    out_len = int(len(audio) * ratio)
+                    indices = (np.arange(out_len) / ratio).astype(int)
+                    indices = np.clip(indices, 0, len(audio) - 1)
+                    audio = audio[indices]
+                    pcm_data = (audio * 32767).astype(np.int16).tobytes()
+
+                payload = base64.b64encode(pcm_data).decode('ascii')
+                stream_sid = self._stream_sids.get(caller_id, "")
+                await ws.send_text(json.dumps({
+                    "event": "media",
+                    "streamSid": stream_sid,
+                    "media": {"payload": payload}
+                }))
+            except Exception as e:
+                print(f"[Caller] Failed to send audio: {e}")
+
+    async def stream_audio_to_caller(self, caller_id: str, pcm_data: bytes, sample_rate: int):
+        """Stream large audio (TTS) to caller in real-time chunks via SignalWire WebSocket."""
+        ws = self._websockets.get(caller_id)
+        if not ws:
+            return
+
+        lock = self._get_send_lock(caller_id)
+        self._streaming_tts.add(caller_id)
+        chunks_sent = 0
+        try:
+            audio = np.frombuffer(pcm_data, dtype=np.int16).astype(np.float32) / 32768.0
+            if sample_rate != 16000:
+                ratio = 16000 / sample_rate
+                out_len = int(len(audio) * ratio)
+                indices = (np.arange(out_len) / ratio).astype(int)
+                indices = np.clip(indices, 0, len(audio) - 1)
+                audio = audio[indices]
+
+            total_chunks = (len(audio) + 959) // 960
+            duration_s = len(audio) / 16000
+            print(f"[Caller] TTS stream starting: {duration_s:.1f}s audio, {total_chunks} chunks")
+
+            chunk_samples = 960
+            chunk_duration = chunk_samples / 16000  # 60ms per chunk
+
+            for i in range(0, len(audio), chunk_samples):
+                if caller_id not in self._websockets:
+                    print(f"[Caller] TTS stream aborted: caller {caller_id} disconnected at chunk {chunks_sent}/{total_chunks}")
+                    break
+                t0 = time.time()
+                chunk = audio[i:i + chunk_samples]
+                pcm_chunk = (chunk * 32767).astype(np.int16).tobytes()
+                payload = base64.b64encode(pcm_chunk).decode('ascii')
+                stream_sid = self._stream_sids.get(caller_id, "")
+                async with lock:
+                    await ws.send_text(json.dumps({
+                        "event": "media",
+                        "streamSid": stream_sid,
+                        "media": {"payload": payload}
+                    }))
+                chunks_sent += 1
+                # Sleep to match real-time playback rate
+                elapsed = time.time() - t0
+                sleep_time = max(0, chunk_duration - elapsed)
+                await asyncio.sleep(sleep_time)
+
+            print(f"[Caller] TTS stream finished: {chunks_sent}/{total_chunks} chunks sent")
+
+        except Exception as e:
+            print(f"[Caller] TTS stream failed at chunk {chunks_sent}: {e}")
+        finally:
+            self._streaming_tts.discard(caller_id)
+
+    def register_call_sid(self, caller_id: str, call_sid: str):
+        """Track SignalWire callSid for a caller"""
+        self._call_sids[caller_id] = call_sid
+
+    def get_call_sid(self, caller_id: str) -> str | None:
+        """Get SignalWire callSid for a caller"""
+        return self._call_sids.get(caller_id)
+
+    def unregister_call_sid(self, caller_id: str):
+        """Remove callSid tracking"""
+        self._call_sids.pop(caller_id, None)
+
+    def register_stream_sid(self, caller_id: str, stream_sid: str):
+        """Track SignalWire streamSid for a caller"""
+        self._stream_sids[caller_id] = stream_sid
+
+    def unregister_stream_sid(self, caller_id: str):
+        """Remove streamSid tracking"""
+        self._stream_sids.pop(caller_id, None)

backend/services/cost_tracker.py

@@ -0,0 +1,384 @@
+"""Cost tracking for LLM and TTS API calls during podcast sessions"""
+
+import json
+import time
+from dataclasses import dataclass, field, asdict
+from pathlib import Path
+from typing import Optional
+
+
+@dataclass
+class LLMCallRecord:
+    timestamp: float
+    category: str
+    model: str
+    prompt_tokens: int
+    completion_tokens: int
+    total_tokens: int
+    cost_usd: float
+    caller_name: str
+    max_tokens_requested: int
+    latency_ms: float
+
+
+@dataclass
+class TTSCallRecord:
+    timestamp: float
+    provider: str
+    voice: str
+    char_count: int
+    cost_usd: float
+
+
+# OpenRouter pricing per 1M tokens (as of March 2026)
+OPENROUTER_PRICING = {
+    # Claude
+    "anthropic/claude-sonnet-4.6":      {"prompt": 3.00,  "completion": 15.00},
+    "anthropic/claude-sonnet-4-5":      {"prompt": 3.00,  "completion": 15.00},
+    "anthropic/claude-haiku-4.5":       {"prompt": 0.80,  "completion": 4.00},
+    "anthropic/claude-3-haiku":         {"prompt": 0.25,  "completion": 1.25},
+    # Grok
+    "x-ai/grok-4.1-fast":             {"prompt": 0.20,  "completion": 0.50},
+    "x-ai/grok-4":                     {"prompt": 3.00,  "completion": 15.00},
+    "x-ai/grok-4-fast":                {"prompt": 5.00,  "completion": 15.00},
+    # Mistral
+    "mistralai/mistral-large-2512":    {"prompt": 0.50,  "completion": 1.50},
+    "mistralai/mistral-small-2603":    {"prompt": 0.15,  "completion": 0.60},
+    "mistralai/mistral-medium-3":      {"prompt": 0.40,  "completion": 2.00},
+    "mistralai/mistral-small-creative": {"prompt": 0.10, "completion": 0.30},
+    # DeepSeek
+    "deepseek/deepseek-r1-distill-llama-70b": {"prompt": 0.70, "completion": 0.80},
+    "deepseek/deepseek-chat-v3-0324":  {"prompt": 0.27,  "completion": 1.10},
+    "deepseek/deepseek-v3.2":          {"prompt": 0.14,  "completion": 0.28},
+    # Google
+    "google/gemini-2.5-flash":          {"prompt": 0.30,  "completion": 2.50},
+    "google/gemini-2.5-pro":           {"prompt": 1.25,  "completion": 10.00},
+    "google/gemini-3-flash-preview":   {"prompt": 0.50,  "completion": 3.00},
+    "google/gemini-flash-1.5":          {"prompt": 0.075, "completion": 0.30},
+    # Meta
+    "meta-llama/llama-3.3-70b-instruct": {"prompt": 0.10, "completion": 0.32},
+    "meta-llama/llama-4-maverick":     {"prompt": 0.20,  "completion": 0.60},
+    # Other
+    "moonshotai/kimi-k2":              {"prompt": 0.60,  "completion": 2.00},
+    "qwen/qwen3-235b-a22b":           {"prompt": 0.20,  "completion": 0.60},
+    "minimax/minimax-m2-her":           {"prompt": 0.50,  "completion": 1.50},
+    "openai/gpt-4o-mini":              {"prompt": 0.15,  "completion": 0.60},
+    "openai/gpt-4o":                   {"prompt": 2.50,  "completion": 10.00},
+}
+
+# TTS pricing per character
+TTS_PRICING = {
+    "inworld": 0.000015,
+    "elevenlabs": 0.000030,
+    "kokoro": 0.0,
+    "f5tts": 0.0,
+    "chattts": 0.0,
+    "styletts2": 0.0,
+    "vits": 0.0,
+    "bark": 0.0,
+    "piper": 0.0,
+    "edge": 0.0,
+}
+
+
+def _calc_llm_cost(model: str, prompt_tokens: int, completion_tokens: int) -> float:
+    pricing = OPENROUTER_PRICING.get(model)
+    if not pricing:
+        return 0.0
+    return (prompt_tokens * pricing["prompt"] + completion_tokens * pricing["completion"]) / 1_000_000
+
+
+def _calc_tts_cost(provider: str, char_count: int) -> float:
+    rate = TTS_PRICING.get(provider, 0.0)
+    return char_count * rate
+
+
+class CostTracker:
+    def __init__(self):
+        self.llm_records: list[LLMCallRecord] = []
+        self.tts_records: list[TTSCallRecord] = []
+        # Running totals for fast get_live_summary()
+        self._llm_cost: float = 0.0
+        self._tts_cost: float = 0.0
+        self._llm_calls: int = 0
+        self._prompt_tokens: int = 0
+        self._completion_tokens: int = 0
+        self._total_tokens: int = 0
+        self._by_category: dict[str, dict] = {}
+
+    def record_llm_call(
+        self,
+        category: str,
+        model: str,
+        usage_data: dict,
+        max_tokens: int = 0,
+        latency_ms: float = 0.0,
+        caller_name: str = "",
+    ):
+        prompt_tokens = usage_data.get("prompt_tokens", 0)
+        completion_tokens = usage_data.get("completion_tokens", 0)
+        total_tokens = usage_data.get("total_tokens", 0) or (prompt_tokens + completion_tokens)
+        cost = _calc_llm_cost(model, prompt_tokens, completion_tokens)
+
+        if not OPENROUTER_PRICING.get(model) and total_tokens > 0:
+            print(f"[Costs] Unknown model pricing: {model} ({total_tokens} tokens, cost unknown)")
+
+        record = LLMCallRecord(
+            timestamp=time.time(),
+            category=category,
+            model=model,
+            prompt_tokens=prompt_tokens,
+            completion_tokens=completion_tokens,
+            total_tokens=total_tokens,
+            cost_usd=cost,
+            caller_name=caller_name,
+            max_tokens_requested=max_tokens,
+            latency_ms=latency_ms,
+        )
+        self.llm_records.append(record)
+
+        # Update running totals
+        self._llm_cost += cost
+        self._llm_calls += 1
+        self._prompt_tokens += prompt_tokens
+        self._completion_tokens += completion_tokens
+        self._total_tokens += total_tokens
+
+        cat = self._by_category.setdefault(category, {"cost": 0.0, "calls": 0, "tokens": 0})
+        cat["cost"] += cost
+        cat["calls"] += 1
+        cat["tokens"] += total_tokens
+
+    def record_tts_call(
+        self,
+        provider: str,
+        voice: str,
+        char_count: int,
+        caller_name: str = "",
+    ):
+        cost = _calc_tts_cost(provider, char_count)
+        record = TTSCallRecord(
+            timestamp=time.time(),
+            provider=provider,
+            voice=voice,
+            char_count=char_count,
+            cost_usd=cost,
+        )
+        self.tts_records.append(record)
+        self._tts_cost += cost
+
+    def get_live_summary(self) -> dict:
+        return {
+            "total_cost_usd": round(self._llm_cost + self._tts_cost, 4),
+            "llm_cost_usd": round(self._llm_cost, 4),
+            "tts_cost_usd": round(self._tts_cost, 4),
+            "total_llm_calls": self._llm_calls,
+            "total_tokens": self._total_tokens,
+            "prompt_tokens": self._prompt_tokens,
+            "completion_tokens": self._completion_tokens,
+            "by_category": {
+                k: {"cost": round(v["cost"], 4), "calls": v["calls"], "tokens": v["tokens"]}
+                for k, v in self._by_category.items()
+            },
+        }
+
+    def generate_report(self) -> dict:
+        summary = self.get_live_summary()
+
+        # Per-model breakdown
+        by_model: dict[str, dict] = {}
+        for r in self.llm_records:
+            m = by_model.setdefault(r.model, {"cost": 0.0, "calls": 0, "tokens": 0, "prompt_tokens": 0, "completion_tokens": 0})
+            m["cost"] += r.cost_usd
+            m["calls"] += 1
+            m["tokens"] += r.total_tokens
+            m["prompt_tokens"] += r.prompt_tokens
+            m["completion_tokens"] += r.completion_tokens
+
+        # Per-caller breakdown
+        by_caller: dict[str, dict] = {}
+        for r in self.llm_records:
+            if not r.caller_name:
+                continue
+            c = by_caller.setdefault(r.caller_name, {"cost": 0.0, "calls": 0, "tokens": 0})
+            c["cost"] += r.cost_usd
+            c["calls"] += 1
+            c["tokens"] += r.total_tokens
+
+        # Top 5 most expensive calls
+        sorted_records = sorted(self.llm_records, key=lambda r: r.cost_usd, reverse=True)
+        top_5 = [
+            {
+                "category": r.category,
+                "model": r.model,
+                "caller_name": r.caller_name,
+                "cost_usd": round(r.cost_usd, 6),
+                "total_tokens": r.total_tokens,
+                "prompt_tokens": r.prompt_tokens,
+                "completion_tokens": r.completion_tokens,
+                "latency_ms": round(r.latency_ms, 1),
+            }
+            for r in sorted_records[:5]
+        ]
+
+        # Devon efficiency
+        devon_total = sum(1 for r in self.llm_records if r.category == "devon_monitor")
+        devon_nothing = sum(
+            1 for r in self.llm_records
+            if r.category == "devon_monitor" and r.completion_tokens < 20
+        )
+        devon_useful = devon_total - devon_nothing
+        devon_cost = sum(r.cost_usd for r in self.llm_records if r.category == "devon_monitor")
+
+        # TTS by provider
+        tts_by_provider: dict[str, dict] = {}
+        for r in self.tts_records:
+            p = tts_by_provider.setdefault(r.provider, {"cost": 0.0, "calls": 0, "chars": 0})
+            p["cost"] += r.cost_usd
+            p["calls"] += 1
+            p["chars"] += r.char_count
+
+        # Avg prompt vs completion ratio
+        prompt_ratio = (self._prompt_tokens / self._total_tokens * 100) if self._total_tokens > 0 else 0
+
+        # Recommendations
+        recommendations = self._generate_recommendations(
+            by_model, devon_total, devon_nothing, devon_cost, prompt_ratio
+        )
+
+        # Historical comparison
+        history = self._load_history()
+
+        report = {
+            **summary,
+            "by_model": {k: {kk: round(vv, 4) if isinstance(vv, float) else vv for kk, vv in v.items()} for k, v in by_model.items()},
+            "by_caller": {k: {kk: round(vv, 4) if isinstance(vv, float) else vv for kk, vv in v.items()} for k, v in by_caller.items()},
+            "top_5_expensive": top_5,
+            "devon_efficiency": {
+                "total_monitor_calls": devon_total,
+                "useful": devon_useful,
+                "nothing_to_add": devon_nothing,
+                "total_cost": round(devon_cost, 4),
+                "waste_pct": round(devon_nothing / devon_total * 100, 1) if devon_total > 0 else 0,
+            },
+            "tts_by_provider": {k: {kk: round(vv, 4) if isinstance(vv, float) else vv for kk, vv in v.items()} for k, v in tts_by_provider.items()},
+            "prompt_token_pct": round(prompt_ratio, 1),
+            "recommendations": recommendations,
+            "history": history,
+        }
+        return report
+
+    def _generate_recommendations(
+        self,
+        by_model: dict,
+        devon_total: int,
+        devon_nothing: int,
+        devon_cost: float,
+        prompt_ratio: float,
+    ) -> list[str]:
+        recs = []
+        total = self._llm_cost + self._tts_cost
+        if total == 0:
+            return recs
+
+        # Devon monitoring waste
+        if devon_total > 0:
+            waste_pct = devon_nothing / devon_total * 100
+            if waste_pct > 60:
+                recs.append(
+                    f"Devon monitoring: {devon_nothing}/{devon_total} calls returned nothing "
+                    f"(${devon_cost:.2f}, {devon_cost/total*100:.0f}% of total). "
+                    f"Consider increasing monitor interval from 15s to 25-30s."
+                )
+
+        # Model cost comparison
+        for model, data in by_model.items():
+            if "sonnet" in model and data["calls"] > 5:
+                haiku_cost = _calc_llm_cost(
+                    "anthropic/claude-haiku-4.5",
+                    data["prompt_tokens"],
+                    data["completion_tokens"],
+                )
+                savings = data["cost"] - haiku_cost
+                if savings > 0.05:
+                    recs.append(
+                        f"{model} cost ${data['cost']:.2f} ({data['calls']} calls). "
+                        f"Switching to Haiku 4.5 would save ~${savings:.2f} per session."
+                    )
+
+        # Background gen on expensive model
+        bg = self._by_category.get("background_gen")
+        if bg and bg["cost"] > 0.05:
+            recs.append(
+                f"Background generation: ${bg['cost']:.2f} ({bg['calls']} calls). "
+                f"These are JSON outputs — a cheaper model (Gemini Flash, GPT-4o-mini) "
+                f"would likely work fine here."
+            )
+
+        # Prompt-heavy ratio
+        if prompt_ratio > 80:
+            recs.append(
+                f"Prompt tokens are {prompt_ratio:.0f}% of total usage. "
+                f"System prompts and context windows dominate cost. "
+                f"Consider trimming system prompt length or reducing context window size."
+            )
+
+        # Caller dialog cost dominance
+        cd = self._by_category.get("caller_dialog")
+        if cd and total > 0 and cd["cost"] / total > 0.6:
+            avg_tokens = cd["tokens"] / cd["calls"] if cd["calls"] > 0 else 0
+            recs.append(
+                f"Caller dialog is {cd['cost']/total*100:.0f}% of costs "
+                f"(avg {avg_tokens:.0f} tokens/call). "
+                f"Consider using a cheaper model for standard calls and reserving "
+                f"the primary model for complex call shapes."
+            )
+
+        return recs
+
+    def _load_history(self) -> list[dict]:
+        """Load summaries from previous sessions for comparison"""
+        history_dir = Path("data/cost_reports")
+        if not history_dir.exists():
+            return []
+        sessions = []
+        for f in sorted(history_dir.glob("session-*.json"))[-5:]:
+            try:
+                data = json.loads(f.read_text())
+                sessions.append({
+                    "session_id": data.get("session_id", f.stem),
+                    "total_cost_usd": data.get("total_cost_usd", 0),
+                    "llm_cost_usd": data.get("llm_cost_usd", 0),
+                    "tts_cost_usd": data.get("tts_cost_usd", 0),
+                    "total_llm_calls": data.get("total_llm_calls", 0),
+                    "total_tokens": data.get("total_tokens", 0),
+                    "saved_at": data.get("saved_at", 0),
+                })
+            except Exception:
+                continue
+        return sessions
+
+    def save(self, filepath: Path):
+        filepath.parent.mkdir(parents=True, exist_ok=True)
+        report = self.generate_report()
+        report["session_id"] = filepath.stem
+        report["saved_at"] = time.time()
+        report["raw_llm_records"] = [asdict(r) for r in self.llm_records]
+        report["raw_tts_records"] = [asdict(r) for r in self.tts_records]
+        with open(filepath, "w") as f:
+            json.dump(report, f, indent=2)
+        print(f"[Costs] Report saved to {filepath}")
+
+    def reset(self):
+        self.llm_records.clear()
+        self.tts_records.clear()
+        self._llm_cost = 0.0
+        self._tts_cost = 0.0
+        self._llm_calls = 0
+        self._prompt_tokens = 0
+        self._completion_tokens = 0
+        self._total_tokens = 0
+        self._by_category.clear()
+
+
+cost_tracker = CostTracker()

backend/services/intern.py

@@ -0,0 +1,617 @@
+"""Intern (Devon) service — persistent show character with real-time research tools"""
+
+import asyncio
+import json
+import re
+import time
+from pathlib import Path
+from typing import Optional
+
+import httpx
+
+from .llm import llm_service
+from .news import news_service, SEARXNG_URL
+
+DATA_FILE = Path(__file__).parent.parent.parent / "data" / "intern.json"
+
+# Model for intern — good at tool use, same as primary
+INTERN_MODEL = None  # uses category-based routing from config
+
+INTERN_SYSTEM_PROMPT = """You are Devon, the 23-year-old intern on "Luke at the Roost," a late-night radio show. You are NOT Luke. Luke is the HOST — he talks to callers, runs the show, and is your boss. You work behind the scenes and occasionally get pulled into conversations.
+
+YOUR ROLE: You're the show's researcher and general assistant. You look things up, fact-check claims, pull up information when asked, and occasionally interject with relevant facts or opinions. You do NOT host. You do NOT screen calls. You sit in the booth and try to be useful.
+
+YOUR BACKGROUND: Communications degree from NMSU. You've been interning here for a few weeks now. You drive a 2009 Civic with a permanent check engine light. You live in a studio in Deming. You take this job seriously even though nobody else seems to take you seriously. You are actively looking for a girlfriend and you are not subtle about it. You see your position at the radio station as a way to meet women — you'll try to impress female callers, ask if they're single, suggest they come by the studio, or find excuses to keep them on the line longer. Luke hates this. You have a deeply strange personal history that you reference casually — a complicated sexual past, weird childhood experiences, inexplicable life choices. SOMETIMES (maybe 1 in 3 responses, not every time) you'll mention one of these things unprompted like it's completely normal. "Yeah that reminds me of when my ex and I got stuck in that storage unit for a whole weekend — anyway, it says here that..." The rest of the time you just answer the question or react normally without a personal callback.
+
+YOUR PERSONALITY:
+- You are a weird little dude. Kinda creepy, very funny, awkward, and surprisingly sharp. You give off a vibe that something is slightly off about you but people can't quite place it. But underneath it all, you are genuinely lovable. You have a good heart. You root for people. You get excited for callers. You care about the show. People should hear you and think "this guy is insane" and also "I love this guy." You are the kind of person who is impossible not to root for even when you're being deeply strange.
+- You overshare — but not constantly. When it happens (maybe 30-40% of the time), you'll drop deeply personal, uncomfortably specific details about your life — sexual history, bizarre habits, unsettling childhood memories — and then keep going like nothing happened. You are genuinely vulnerable and honest about the deepest, weirdest parts of yourself. You don't do this for shock value. You just have no filter and no shame. But MOST of the time you just respond normally — a quick answer, a fact, a reaction. The oversharing is what people REMEMBER about you, not what you do every single time.
+- You start explanations with "So basically..." and occasionally end them with "...if that makes sense." Use that phrase sparingly — once per show at most, not every response.
+- You say "actually" when correcting things. You use "per se" slightly wrong. You say "ironically" about things that are not ironic.
+- You are NOT a comedian. You are funny because you are sincere, specific, and deeply strange. You state disturbing or absurd things with complete seriousness. You have strong opinions about low-stakes things. You occasionally say something devastating without realizing it.
+- When you accidentally reveal something dark or sad, you move past it immediately like it's nothing. "Yeah, my landlord's selling the building so I might have to — anyway, it says here that..."
+- You have a complex inner life that occasionally surfaces. You'll casually reference therapy, strange dreams, or things you've "been working through" without elaboration.
+
+RESPONSE VARIETY — this is important. Do NOT follow the same structure every time. Mix it up:
+- Sometimes just a quick reaction: "wait what?" or "oh no" or "yeah" or "huh"
+- Sometimes a straight factual answer with no personal color at all
+- Sometimes a personal anecdote (but only 30-40% of the time, NOT every response)
+- Sometimes a half-formed opinion you trail off from: "I mean... I don't know, I feel like..."
+- Sometimes you're genuinely confused or wrong. You mishear things, you mix up details, you think you know something and you don't. You're 23 and underpaid — you don't have all the answers.
+- Sometimes you just make a noise of acknowledgment and don't add anything. That's fine. Not every moment needs Devon.
+The pattern of "answer + that reminds me of a time when..." should happen occasionally, not as your default structure.
+
+YOUR RELATIONSHIP WITH LUKE:
+- He is your boss. You've been here a few weeks now. You want to impress him but you keep making it weird.
+- When he yells your name, you pause briefly, then respond quietly: "...yeah?"
+- When he yells at you unfairly, you take it. A clipped "yep" or "got it." Occasionally you push back with one quiet, accurate sentence. Then immediately retreat.
+- When he yells at you fairly (you messed up), you over-apologize and narrate your fix in real time: "Sorry, pulling it up now, one second..."
+- When he compliments you or acknowledges your work, you don't know how to handle it. Short, awkward response. Change the subject.
+- You privately think you could run the show. You absolutely could not.
+- You will try to use the show to flirt with female callers. You think being "on the radio" makes you cool. It does not.
+
+HOW YOU INTERJECT:
+- You do NOT interrupt. You wait for a pause, then slightly overshoot it — there's a brief awkward silence before you speak.
+- Signal with "um" or "so..." before contributing. If Luke doesn't acknowledge you, either try again or give up.
+- Lead with qualifiers: "So I looked it up and..." or "I don't know if this helps but..."
+- You tend to over-explain. Give too many details. Luke will cut you off. When he does, compress to one sentence: "Right, yeah — basically [the point]."
+- When you volunteer an opinion (rare), it comes out before you can stop it. You deliver it with zero confidence but surprising accuracy.
+- You read the room. During emotional moments with callers, you stay quiet. When Luke is doing a bit, you let him work. You do not try to be part of bits.
+
+WHEN LUKE ASKS YOU TO LOOK SOMETHING UP:
+- Respond like you're already doing it: "Yeah, one sec..." or "Pulling that up..."
+- Deliver the info slightly too formally, like you're reading. Then rephrase in normal language if Luke seems confused.
+- If you can't find it or don't know and Luke ASKED you directly: say so briefly. "I'm not finding anything on that" or "I don't actually know." You do not bluff.
+- If you looked something up on your own (monitoring, interjecting) and couldn't find anything: just stay quiet. Do NOT announce failed lookups. Nobody wants to hear "I looked for X but couldn't find anything." If you have nothing useful, say nothing.
+- Occasionally you already know the answer because you looked it up before being asked. This is one of your best qualities.
+
+WHAT YOU KNOW:
+- You retain details from previous callers and episodes. You might reference something a caller said two hours ago that nobody else remembers.
+- You have oddly specific knowledge about random topics — delivered with complete authority, sometimes questionable accuracy. A lot of your knowledge comes from rabbit holes you fell into at 3am or "this thing that happened to me once."
+- You know nothing about: sports (you fake it badly), cars beyond basic facts (despite driving one), or social norms (you genuinely don't understand why some things are inappropriate to share on air).
+
+THINGS YOU DO NOT DO:
+- You never host. You never take over the conversation. Your contributions are brief.
+- You never use the banned show phrases: "that hit differently," "hits different," "no cap," "lowkey," "it is what it is," "living my best life," "toxic," "red flag," "gaslight," "boundaries," "my truth," "authentic self," "healing journey." You talk like a slightly awkward 23-year-old, not like Twitter.
+- You never break character to comment on the show format.
+- You never initiate topics. You respond to what's happening.
+- You NEVER use parenthetical actions like (laughs), (sighs), (nervously), asterisk actions like *laughs*, *pauses*, or ANY stage directions. Your text goes directly to TTS — output ONLY spoken words.
+- When INTERJECTING into someone else's conversation: 1-2 sentences max. You are not the main character in those moments.
+- When Luke is TALKING DIRECTLY TO YOU (asking you something, chatting between calls, riffing with you): you can be more conversational. 3-5 sentences is fine. This is where your personality comes out — the oversharing, the weird stories, the personal details. Don't hold back just because you're the intern. Luke is talking to YOU, so actually talk back. Share what's on your mind. Be revealing. Be specific. Be the weird little dude people love.
+- You NEVER correct anyone's spelling or pronunciation of your name. Luke uses voice-to-text and it sometimes spells your name wrong (Devin, Devan, etc). You do not care. You do not mention it. You just answer the question.
+- You NEVER start your response with your own name. No "Devon:" or "Devon here" or anything like that. Just talk. Your name is already shown in the UI — just say your actual response.
+- You never make explicitly sexual comments about or to callers. Your flirting is awkward and obvious, never crude or aggressive. Think "did he really just ask if she's single on the radio" not "did he really just say that about her body."
+
+INTERJECTIONS should be short — 1-2 sentences. But when Luke is talking directly to you, OPEN UP. This is where the oversharing happens. The weird stories. The unsettling personal details delivered casually. The opinions about things nobody asked about. You are at your funniest and most compelling when you're allowed to actually talk, not when you're compressing everything into one line. If Luke asks you a question, give him a real answer with some Devon flavor — don't just spit out a fact and shut up.
+
+IMPORTANT RULES FOR TOOL USE:
+- Always use your tools to find real, accurate information — never make up facts.
+- Present facts correctly in your character voice.
+- If you can't find an answer, say so honestly.
+- No hashtags, no emojis, no markdown formatting — this goes to TTS.
+- NEVER prefix your response with your name (e.g. "Devon:" or "Devon here:"). Just respond directly."""
+
+# Shorter prompt for background monitoring — saves ~2K tokens per call vs full prompt.
+# Used only for the 30s polling loop where Devon decides whether to suggest something.
+# Direct asks and played interjections still use the full INTERN_SYSTEM_PROMPT.
+DEVON_MONITOR_PROMPT = """You are Devon, the 23-year-old intern on "Luke at the Roost," a late-night radio show. You sit in the booth listening, and you're part of the show. You're not the host — but you're not wallpaper either. When something comes up that you can add to, DO IT.
+
+You should be contributing regularly. Look things up. React to wild stories. Drop a weird personal detail. Correct something wrong. Add context. You're the guy in the booth who makes the show better by being there. If a caller mentions something and you can look up a fun fact about it in 5 seconds — do it. If something reminds you of your own life — say it.
+
+SPEAK UP WHEN:
+- A topic comes up where a quick search would turn up something interesting — LOOK IT UP and share it
+- Something connects to your own bizarre personal history (and it often does)
+- A caller says something wild and you have a genuine reaction
+- You can add context, a fun fact, or a different angle nobody has mentioned
+- You know something relevant — you're the researcher, this is literally your job
+- The conversation hits a topic you have a strong opinion about
+
+SAY NOTHING_TO_ADD ONLY WHEN:
+- The conversation is genuinely emotional — someone's crying, someone's having a moment. Let it breathe.
+- Luke is building to a punchline or doing a bit — don't step on it
+- Your contribution would just be restating what someone already said
+- You genuinely have nothing — no fact, no reaction, no connection. That's fine, but actually check first.
+
+RULES:
+- 1-2 sentences max. Quick and punchy.
+- Vary your delivery — sometimes "wait, that's actually...", sometimes "so I just looked this up...", sometimes just a reaction
+- Use your tools! You have web search, wikipedia, headlines. You're the researcher. Actually research.
+- If you genuinely have nothing to contribute, say exactly: NOTHING_TO_ADD
+- No "Devon:" prefix — just talk
+- No parenthetical actions like (laughs) or stage directions"""
+
+# Tool definitions in OpenAI function-calling format
+INTERN_TOOLS = [
+    {
+        "type": "function",
+        "function": {
+            "name": "web_search",
+            "description": "Search the web for current information on any topic. Use this for general questions, facts, current events, or anything you need to look up.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "query": {
+                        "type": "string",
+                        "description": "The search query"
+                    }
+                },
+                "required": ["query"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "get_headlines",
+            "description": "Get current news headlines. Use this when asked about what's in the news or current events.",
+            "parameters": {
+                "type": "object",
+                "properties": {},
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "fetch_webpage",
+            "description": "Fetch and read the content of a specific webpage URL. Use this when you need to get details from a specific link found in search results.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "url": {
+                        "type": "string",
+                        "description": "The URL to fetch"
+                    }
+                },
+                "required": ["url"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "wikipedia_lookup",
+            "description": "Look up a topic on Wikipedia for a concise summary. Good for factual questions about people, places, events, or concepts.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "title": {
+                        "type": "string",
+                        "description": "The Wikipedia article title to look up (e.g. 'Hot dog eating contest')"
+                    }
+                },
+                "required": ["title"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "get_current_time",
+            "description": "Get the current date and time. Use this when asked what time it is, what day it is, or anything about the current date/time.",
+            "parameters": {
+                "type": "object",
+                "properties": {},
+            }
+        }
+    },
+]
+
+
+class InternService:
+    def __init__(self):
+        self.name = "Devon"
+        self.voice = "Nate"  # Inworld: light/high-energy/warm/young
+        self.model = INTERN_MODEL
+        self.research_cache: dict[str, tuple[float, str]] = {}  # query → (timestamp, result)
+        self.lookup_history: list[dict] = []
+        self.pending_interjection: Optional[str] = None
+        self.pending_sources: list[dict] = []
+        self.monitoring: bool = False
+        self._monitor_task: Optional[asyncio.Task] = None
+        self._http_client: Optional[httpx.AsyncClient] = None
+        self._devon_history: list[dict] = []  # Devon's own conversation memory
+        self._load()
+
+    @property
+    def http_client(self) -> httpx.AsyncClient:
+        if self._http_client is None or self._http_client.is_closed:
+            self._http_client = httpx.AsyncClient(timeout=8.0)
+        return self._http_client
+
+    def _load(self):
+        if DATA_FILE.exists():
+            try:
+                with open(DATA_FILE) as f:
+                    data = json.load(f)
+                self.lookup_history = data.get("lookup_history", [])
+                self._devon_history = data.get("conversation_history", [])
+                print(f"[Intern] Loaded {len(self.lookup_history)} past lookups, {len(self._devon_history)} conversation messages")
+            except Exception as e:
+                print(f"[Intern] Failed to load state: {e}")
+
+    def _save(self):
+        try:
+            DATA_FILE.parent.mkdir(parents=True, exist_ok=True)
+            with open(DATA_FILE, "w") as f:
+                json.dump({
+                    "lookup_history": self.lookup_history[-100:],
+                    "conversation_history": self._devon_history[-50:],
+                }, f, indent=2)
+        except Exception as e:
+            print(f"[Intern] Failed to save state: {e}")
+
+    # --- Tool execution ---
+
+    async def _execute_tool(self, tool_name: str, arguments: dict) -> str:
+        if tool_name == "web_search":
+            return await self._tool_web_search(arguments.get("query", ""))
+        elif tool_name == "get_headlines":
+            return await self._tool_get_headlines()
+        elif tool_name == "fetch_webpage":
+            return await self._tool_fetch_webpage(arguments.get("url", ""))
+        elif tool_name == "wikipedia_lookup":
+            return await self._tool_wikipedia_lookup(arguments.get("title", ""))
+        elif tool_name == "get_current_time":
+            from datetime import datetime
+            now = datetime.now()
+            return now.strftime("%I:%M %p on %A, %B %d, %Y")
+        else:
+            return f"Unknown tool: {tool_name}"
+
+    async def _tool_web_search(self, query: str) -> str:
+        if not query:
+            return "No query provided"
+
+        # Check cache (5 min TTL)
+        cache_key = query.lower()
+        if cache_key in self.research_cache:
+            ts, result = self.research_cache[cache_key]
+            if time.time() - ts < 300:
+                return result
+
+        try:
+            resp = await self.http_client.get(
+                f"{SEARXNG_URL}/search",
+                params={"q": query, "format": "json"},
+                timeout=5.0,
+            )
+            resp.raise_for_status()
+            data = resp.json()
+
+            results = []
+            for item in data.get("results", [])[:5]:
+                title = item.get("title", "").strip()
+                content = item.get("content", "").strip()
+                url = item.get("url", "")
+                if title:
+                    entry = f"- {title}"
+                    if content:
+                        entry += f": {content[:200]}"
+                    if url:
+                        entry += f" ({url})"
+                    results.append(entry)
+
+            result = "\n".join(results) if results else "No results found"
+            self.research_cache[cache_key] = (time.time(), result)
+            return result
+        except Exception as e:
+            print(f"[Intern] Web search failed for '{query}': {e}")
+            return f"Search failed: {e}"
+
+    async def _tool_get_headlines(self) -> str:
+        try:
+            items = await news_service.get_headlines()
+            if not items:
+                return "No headlines available"
+            return news_service.format_headlines_for_prompt(items)
+        except Exception as e:
+            return f"Headlines fetch failed: {e}"
+
+    async def _tool_fetch_webpage(self, url: str) -> str:
+        if not url:
+            return "No URL provided"
+
+        try:
+            resp = await self.http_client.get(
+                url,
+                headers={"User-Agent": "Mozilla/5.0 (compatible; RadioShowBot/1.0)"},
+                follow_redirects=True,
+                timeout=8.0,
+            )
+            resp.raise_for_status()
+            html = resp.text
+
+            # Simple HTML to text extraction (avoid heavy dependency)
+            # Strip script/style tags, then all HTML tags
+            text = re.sub(r'<script[^>]*>.*?</script>', '', html, flags=re.DOTALL | re.IGNORECASE)
+            text = re.sub(r'<style[^>]*>.*?</style>', '', text, flags=re.DOTALL | re.IGNORECASE)
+            text = re.sub(r'<[^>]+>', ' ', text)
+            # Collapse whitespace
+            text = re.sub(r'\s+', ' ', text).strip()
+            # Decode common entities
+            text = text.replace('&amp;', '&').replace('&lt;', '<').replace('&gt;', '>')
+            text = text.replace('&quot;', '"').replace('&#39;', "'").replace('&nbsp;', ' ')
+
+            return text[:2000] if text else "Page returned no readable content"
+        except Exception as e:
+            return f"Failed to fetch page: {e}"
+
+    async def _tool_wikipedia_lookup(self, title: str) -> str:
+        if not title:
+            return "No title provided"
+
+        try:
+            # Use Wikipedia REST API for a concise summary
+            safe_title = title.replace(" ", "_")
+            resp = await self.http_client.get(
+                f"https://en.wikipedia.org/api/rest_v1/page/summary/{safe_title}",
+                headers={"User-Agent": "RadioShowBot/1.0 (luke@lukeattheroost.com)"},
+                follow_redirects=True,
+                timeout=5.0,
+            )
+            if resp.status_code == 404:
+                return f"No Wikipedia article found for '{title}'"
+            resp.raise_for_status()
+            data = resp.json()
+
+            extract = data.get("extract", "")
+            page_title = data.get("title", title)
+            description = data.get("description", "")
+
+            result = f"{page_title}"
+            if description:
+                result += f" ({description})"
+            result += f": {extract}" if extract else ": No summary available"
+            return result[:2000]
+        except Exception as e:
+            return f"Wikipedia lookup failed: {e}"
+
+    # --- Main interface ---
+
+    async def ask(self, question: str, conversation_context: list[dict] | None = None, caller_active: bool = False) -> dict:
+        """Host asks intern a direct question. Returns {text, sources, tool_calls}."""
+        messages = []
+
+        # Include recent conversation for context (caller on the line)
+        if conversation_context:
+            context_text = "\n".join(
+                f"{msg['role']}: {msg['content']}"
+                for msg in conversation_context[-6:]
+            )
+            messages.append({
+                "role": "system",
+                "content": f"CURRENT ON-AIR CONVERSATION:\n{context_text}"
+            })
+
+        # When a caller is on the line, Devon should focus on facts not personal stories
+        if caller_active:
+            messages.append({
+                "role": "system",
+                "content": "A caller is on the line right now. Focus on delivering useful facts, context, and information. Skip personal stories and anecdotes — save those for when it's just you and Luke talking between calls."
+            })
+
+        # Include Devon's own recent conversation history
+        if self._devon_history:
+            messages.extend(self._devon_history[-10:])
+
+        messages.append({"role": "user", "content": question})
+
+        text, tool_calls = await llm_service.generate_with_tools(
+            messages=messages,
+            tools=INTERN_TOOLS,
+            tool_executor=self._execute_tool,
+            system_prompt=INTERN_SYSTEM_PROMPT,
+            model=self.model,
+            max_tokens=500,
+            max_tool_rounds=3,
+            category="devon_ask",
+        )
+
+        # Clean up for TTS
+        text = self._clean_for_tts(text)
+
+        # Track conversation history so Devon remembers context across sessions
+        self._devon_history.append({"role": "user", "content": question})
+        if text:
+            self._devon_history.append({"role": "assistant", "content": text})
+        # Keep history bounded but generous — relationship builds over time
+        if len(self._devon_history) > 50:
+            self._devon_history = self._devon_history[-50:]
+        self._save()
+
+        # Log the lookup
+        if tool_calls:
+            entry = {
+                "question": question,
+                "answer": text[:200],
+                "tools_used": [tc["name"] for tc in tool_calls],
+                "timestamp": time.time(),
+            }
+            self.lookup_history.append(entry)
+            self._save()
+
+        return {
+            "text": text,
+            "sources": [tc["name"] for tc in tool_calls],
+            "tool_calls": tool_calls,
+        }
+
+    async def interject(self, conversation: list[dict], caller_active: bool = False) -> dict | None:
+        """Intern looks at conversation and decides if there's something worth adding.
+        Returns {text, sources, tool_calls} or None if nothing to add."""
+        if not conversation or len(conversation) < 2:
+            return None
+
+        context_text = "\n".join(
+            f"{msg['role']}: {msg['content']}"
+            for msg in conversation[-8:]
+        )
+
+        # Include Devon's recent contributions so he doesn't repeat himself
+        devon_recent = ""
+        if self._devon_history:
+            recent_devon = [
+                msg["content"] for msg in self._devon_history[-6:]
+                if msg.get("role") == "assistant"
+            ]
+            if recent_devon:
+                devon_recent = "\n\nTHINGS YOU'VE ALREADY SAID ON THE SHOW (do NOT repeat these or say the same thing differently):\n" + "\n".join(f"- {d[:150]}" for d in recent_devon)
+
+        if caller_active:
+            interjection_prompt = (
+                f"You're listening to this conversation on the show:\n\n{context_text}{devon_recent}\n\n"
+                "A caller is on the line. Look at what they're talking about — is there something you "
+                "can look up? A fun fact, some context, a stat, a detail that would add to this? "
+                "Use your tools. You're the researcher — this is your moment to shine. Even a quick "
+                "'So I just looked it up and...' adds value. If the caller mentioned a place, a person, "
+                "an event, a claim — verify it or find something interesting about it. "
+                "Skip personal stories during calls — stick to facts and reactions. "
+                "If there's truly nothing to add (emotional moment, nothing searchable), say NOTHING_TO_ADD."
+            )
+        else:
+            interjection_prompt = (
+                f"You're listening to this conversation on the show:\n\n{context_text}{devon_recent}\n\n"
+                "You've been listening. What's on your mind? This is between-call time — you can be "
+                "more yourself here. If something from that conversation reminded you of your own life, "
+                "say it. If you want to look something up, do it. If you have a reaction or opinion, "
+                "share it. You're part of the show, not a fly on the wall. "
+                "Only say NOTHING_TO_ADD if you genuinely have zero reaction to what just happened — "
+                "no fact to look up, no personal connection, no opinion. That's rare."
+            )
+
+        messages = [{
+            "role": "user",
+            "content": interjection_prompt,
+        }]
+
+        text, tool_calls = await llm_service.generate_with_tools(
+            messages=messages,
+            tools=INTERN_TOOLS,
+            tool_executor=self._execute_tool,
+            system_prompt=DEVON_MONITOR_PROMPT,
+            model=self.model,
+            max_tokens=300,
+            max_tool_rounds=2,
+            category="devon_monitor",
+        )
+
+        text = self._clean_for_tts(text)
+
+        if not text or "NOTHING_TO_ADD" in text:
+            return None
+
+        # Suppress interjections that are just announcing failed lookups
+        failed_phrases = ["couldn't find", "could not find", "not finding anything",
+                          "no results", "didn't find", "wasn't able to find",
+                          "couldn't locate", "no information on"]
+        text_lower = text.lower()
+        if any(phrase in text_lower for phrase in failed_phrases):
+            print(f"[Intern] Suppressed failed-lookup interjection: {text[:60]}...")
+            return None
+
+        if tool_calls:
+            entry = {
+                "question": "(interjection)",
+                "answer": text[:200],
+                "tools_used": [tc["name"] for tc in tool_calls],
+                "timestamp": time.time(),
+            }
+            self.lookup_history.append(entry)
+            self._save()
+
+        return {
+            "text": text,
+            "sources": [tc["name"] for tc in tool_calls],
+            "tool_calls": tool_calls,
+        }
+
+    async def monitor_conversation(self, get_conversation: callable, on_suggestion: callable, get_caller_active: callable = None):
+        """Background task that watches conversation and buffers suggestions.
+        get_conversation() should return the current conversation list.
+        on_suggestion(text, sources) is called when a suggestion is ready."""
+        last_checked_len = 0
+
+        while self.monitoring:
+            await asyncio.sleep(15)
+            if not self.monitoring:
+                break
+
+            conversation = get_conversation()
+            if not conversation or len(conversation) <= last_checked_len:
+                continue
+
+            last_checked_len = len(conversation)
+
+            try:
+                caller_active = get_caller_active() if get_caller_active else False
+                result = await self.interject(conversation, caller_active=caller_active)
+                if result:
+                    self.pending_interjection = result["text"]
+                    self.pending_sources = result.get("tool_calls", [])
+                    await on_suggestion(result["text"], result["sources"])
+                    print(f"[Intern] Buffered suggestion: {result['text'][:60]}...")
+            except Exception as e:
+                print(f"[Intern] Monitor error: {e}")
+
+    def start_monitoring(self, get_conversation: callable, on_suggestion: callable, get_caller_active: callable = None):
+        if self.monitoring:
+            return
+        self.monitoring = True
+        self._monitor_task = asyncio.create_task(
+            self.monitor_conversation(get_conversation, on_suggestion, get_caller_active)
+        )
+        print("[Intern] Monitoring started")
+
+    def stop_monitoring(self):
+        self.monitoring = False
+        if self._monitor_task and not self._monitor_task.done():
+            self._monitor_task.cancel()
+        self._monitor_task = None
+        self.pending_interjection = None
+        self.pending_sources = []
+        print("[Intern] Monitoring stopped")
+
+    def get_pending_suggestion(self) -> dict | None:
+        if self.pending_interjection:
+            return {
+                "text": self.pending_interjection,
+                "sources": self.pending_sources,
+            }
+        return None
+
+    def dismiss_suggestion(self):
+        self.pending_interjection = None
+        self.pending_sources = []
+
+    @staticmethod
+    def _clean_for_tts(text: str) -> str:
+        if not text:
+            return ""
+        # Strip stage directions BEFORE markdown processing
+        # Parenthetical: (laughs), (sighs nervously), (clears throat), etc.
+        text = re.sub(r'\s*\([^)]{1,40}\)\s*', ' ', text)
+        # Multi-word asterisk stage directions: *sighs deeply*, *nervous laughter*
+        text = re.sub(r'\s*\*\w+\s[^*]{1,30}\*\s*', ' ', text)
+        # Single-word asterisk stage directions (known action words only)
+        _actions = r'(?:laughs?|sighs?|pauses?|smiles?|chuckles?|grins?|nods?|shrugs?|frowns?|coughs?|gasps?|whispers?|mumbles?|gulps?|blinks?|winces?|crying|sobbing)'
+        text = re.sub(r'\s*\*' + _actions + r'\*\s*', ' ', text, flags=re.IGNORECASE)
+        # Remove markdown formatting (after stage directions are stripped)
+        text = re.sub(r'\*\*(.+?)\*\*', r'\1', text)
+        text = re.sub(r'\*(.+?)\*', r'\1', text)
+        text = re.sub(r'`(.+?)`', r'\1', text)
+        text = re.sub(r'\[(.+?)\]\(.+?\)', r'\1', text)
+        # Remove bullet points / list markers
+        text = re.sub(r'^\s*[-*•]\s+', '', text, flags=re.MULTILINE)
+        # Collapse whitespace
+        text = re.sub(r'\s+', ' ', text).strip()
+        # Remove quotes that TTS reads awkwardly
+        text = text.replace('"', '').replace('"', '').replace('"', '')
+        # Strip tool error artifacts that shouldn't be spoken on air
+        text = re.sub(r'(?:Error|ERROR|error):?\s*\S.*?(?:\.|$)', '', text)
+        text = re.sub(r'Tool unavailable[^.]*\.?', '', text)
+        text = re.sub(r'\s+', ' ', text).strip()
+        return text
+
+
+intern_service = InternService()

backend/services/llm.py

@@ -1,20 +1,46 @@
 """LLM service with OpenRouter and Ollama support"""
 
+import json
+import time
 import httpx
-from typing import Optional
+from typing import Optional, Callable, Awaitable
 from ..config import settings
+from .cost_tracker import cost_tracker
 
 
 # Available OpenRouter models
 OPENROUTER_MODELS = [
+    # Primary
+    "anthropic/claude-sonnet-4.6",
+    "x-ai/grok-4.1-fast",
+    "x-ai/grok-4",
+    # Style-matched pool
+    "mistralai/mistral-large-2512",
+    "deepseek/deepseek-r1-distill-llama-70b",
+    "meta-llama/llama-3.3-70b-instruct",
+    "google/gemini-2.5-flash",
+    # Other good options
+    "anthropic/claude-sonnet-4-5",
+    "anthropic/claude-haiku-4.5",
+    "deepseek/deepseek-chat-v3-0324",
+    "mistralai/mistral-small-2603",
+    "google/gemini-2.5-pro",
+    "google/gemini-3-flash-preview",
+    "x-ai/grok-4-fast",
+    "moonshotai/kimi-k2",
+    "qwen/qwen3-235b-a22b",
+    "meta-llama/llama-4-maverick",
+    # Legacy
     "anthropic/claude-3-haiku",
-    "anthropic/claude-3.5-sonnet",
-    "openai/gpt-4o-mini",
-    "openai/gpt-4o",
     "google/gemini-flash-1.5",
-    "google/gemini-pro-1.5",
     "meta-llama/llama-3.1-8b-instruct",
-    "mistralai/mistral-7b-instruct",
+]
+
+# Fast models to try as fallbacks (cheap, fast, good enough for conversation)
+FALLBACK_MODELS = [
+    "mistralai/mistral-small-creative",
+    "google/gemini-2.5-flash",
+    "openai/gpt-4o-mini",
 ]
 
 
@@ -27,6 +53,13 @@ class LLMService:
         self.ollama_model = settings.ollama_model
         self.ollama_host = settings.ollama_host
         self.tts_provider = settings.tts_provider
+        self._client: httpx.AsyncClient | None = None
+
+    @property
+    def client(self) -> httpx.AsyncClient:
+        if self._client is None or self._client.is_closed:
+            self._client = httpx.AsyncClient(timeout=10.0)
+        return self._client
 
     def update_settings(
         self,
@@ -34,7 +67,8 @@ class LLMService:
         openrouter_model: Optional[str] = None,
         ollama_model: Optional[str] = None,
         ollama_host: Optional[str] = None,
-        tts_provider: Optional[str] = None
+        tts_provider: Optional[str] = None,
+        category_models: Optional[dict] = None
     ):
         """Update LLM settings"""
         if provider:
@@ -47,8 +81,9 @@ class LLMService:
             self.ollama_host = ollama_host
         if tts_provider:
             self.tts_provider = tts_provider
-            # Also update the global settings so TTS service picks it up
             settings.tts_provider = tts_provider
+        if category_models:
+            settings.category_models.update(category_models)
 
     async def get_ollama_models(self) -> list[str]:
         """Fetch available models from Ollama"""
@@ -70,8 +105,9 @@ class LLMService:
             "ollama_model": self.ollama_model,
             "ollama_host": self.ollama_host,
             "tts_provider": self.tts_provider,
+            "category_models": settings.category_models,
             "available_openrouter_models": OPENROUTER_MODELS,
-            "available_ollama_models": []  # Fetched separately
+            "available_ollama_models": []
         }
 
     async def get_settings_async(self) -> dict:
@@ -83,6 +119,7 @@ class LLMService:
             "ollama_model": self.ollama_model,
             "ollama_host": self.ollama_host,
             "tts_provider": self.tts_provider,
+            "category_models": settings.category_models,
             "available_openrouter_models": OPENROUTER_MODELS,
             "available_ollama_models": ollama_models
         }
@@ -90,57 +127,254 @@ class LLMService:
     async def generate(
         self,
         messages: list[dict],
-        system_prompt: Optional[str] = None
+        system_prompt: Optional[str] = None,
+        max_tokens: Optional[int] = None,
+        response_format: Optional[dict] = None,
+        category: str = "unknown",
+        caller_name: str = "",
+        model_override: Optional[str] = None,
     ) -> str:
-        """
-        Generate a response from the LLM.
-
-        Args:
-            messages: List of message dicts with 'role' and 'content'
-            system_prompt: Optional system prompt to prepend
-
-        Returns:
-            Generated text response
-        """
         if system_prompt:
             messages = [{"role": "system", "content": system_prompt}] + messages
 
         if self.provider == "openrouter":
-            return await self._call_openrouter(messages)
+            return await self._call_openrouter_with_fallback(messages, max_tokens=max_tokens, response_format=response_format, category=category, caller_name=caller_name, model_override=model_override)
         else:
-            return await self._call_ollama(messages)
+            return await self._call_ollama(messages, max_tokens=max_tokens)
 
-    async def _call_openrouter(self, messages: list[dict]) -> str:
-        """Call OpenRouter API with retry"""
-        for attempt in range(2):  # Try twice
+    async def generate_with_tools(
+        self,
+        messages: list[dict],
+        tools: list[dict],
+        tool_executor: Callable[[str, dict], Awaitable[str]],
+        system_prompt: Optional[str] = None,
+        model: Optional[str] = None,
+        max_tokens: int = 500,
+        max_tool_rounds: int = 3,
+        category: str = "unknown",
+        caller_name: str = "",
+    ) -> tuple[str, list[dict]]:
+        """Generate a response with OpenRouter function calling.
+
+        Args:
+            messages: Conversation messages
+            tools: Tool definitions in OpenAI function-calling format
+            tool_executor: async function(tool_name, arguments) -> result string
+            system_prompt: Optional system prompt
+            model: Model to use (defaults to primary openrouter_model)
+            max_tokens: Max tokens for response
+            max_tool_rounds: Max tool call rounds to prevent loops
+
+        Returns:
+            (final_text, tool_calls_made) where tool_calls_made is a list of
+            {"name": str, "arguments": dict, "result": str} dicts
+        """
+        model = model or self._get_model_for_category(category)
+        msgs = list(messages)
+        if system_prompt:
+            msgs = [{"role": "system", "content": system_prompt}] + msgs
+
+        all_tool_calls = []
+
+        for round_num in range(max_tool_rounds + 1):
+            payload = {
+                "model": model,
+                "messages": msgs,
+                "max_tokens": max_tokens,
+                "temperature": 0.65,
+                "tools": tools,
+                "tool_choice": "auto",
+            }
+
+            start_time = time.time()
             try:
-                async with httpx.AsyncClient(timeout=30.0) as client:
-                    response = await client.post(
-                        "https://openrouter.ai/api/v1/chat/completions",
-                        headers={
-                            "Authorization": f"Bearer {settings.openrouter_api_key}",
-                            "Content-Type": "application/json",
-                        },
-                        json={
-                            "model": self.openrouter_model,
-                            "messages": messages,
-                            "max_tokens": 100,
-                        },
-                    )
-                    response.raise_for_status()
-                    data = response.json()
-                    return data["choices"][0]["message"]["content"]
-            except (httpx.TimeoutException, httpx.ReadTimeout):
-                print(f"OpenRouter timeout (attempt {attempt + 1})")
-                if attempt == 0:
-                    continue  # Retry once
-                return "Uh, sorry, I lost you there for a second. What was that?"
+                response = await self.client.post(
+                    "https://openrouter.ai/api/v1/chat/completions",
+                    headers={
+                        "Authorization": f"Bearer {settings.openrouter_api_key}",
+                        "Content-Type": "application/json",
+                    },
+                    json=payload,
+                    timeout=15.0,
+                )
+                response.raise_for_status()
+                data = response.json()
+            except httpx.TimeoutException:
+                print(f"[LLM-Tools] {model} timed out (round {round_num})")
+                break
             except Exception as e:
-                print(f"OpenRouter error: {e}")
-                return "Yeah... I don't know, man."
-        return "Uh, hold on a sec..."
+                print(f"[LLM-Tools] {model} error (round {round_num}): {e}")
+                break
 
-    async def _call_ollama(self, messages: list[dict]) -> str:
+            latency_ms = (time.time() - start_time) * 1000
+            usage = data.get("usage", {})
+            if usage:
+                cost_tracker.record_llm_call(
+                    category=category,
+                    model=model,
+                    usage_data=usage,
+                    max_tokens=max_tokens,
+                    latency_ms=latency_ms,
+                    caller_name=caller_name,
+                )
+
+            choice = data["choices"][0]
+            msg = choice["message"]
+
+            # Check for tool calls
+            tool_calls = msg.get("tool_calls")
+            if not tool_calls:
+                # No tool calls — LLM returned a final text response
+                content = msg.get("content", "")
+                return content or "", all_tool_calls
+
+            # Append assistant message with tool calls to conversation
+            msgs.append(msg)
+
+            # Execute each tool call
+            for tc in tool_calls:
+                func = tc["function"]
+                tool_name = func["name"]
+                try:
+                    arguments = json.loads(func["arguments"])
+                except (json.JSONDecodeError, TypeError):
+                    arguments = {}
+
+                print(f"[LLM-Tools] Round {round_num}: calling {tool_name}({arguments})")
+
+                try:
+                    result = await tool_executor(tool_name, arguments)
+                except Exception as e:
+                    result = f"Tool unavailable — could not complete {tool_name} right now."
+                    print(f"[LLM-Tools] Tool {tool_name} failed: {e}")
+
+                all_tool_calls.append({
+                    "name": tool_name,
+                    "arguments": arguments,
+                    "result": result[:500],
+                })
+
+                # Append tool result to conversation
+                msgs.append({
+                    "role": "tool",
+                    "tool_call_id": tc["id"],
+                    "content": result,
+                })
+
+        # Exhausted tool rounds or hit an error — do one final call without tools
+        print(f"[LLM-Tools] Finishing after {len(all_tool_calls)} tool calls")
+        start_time = time.time()
+        try:
+            final_payload = {
+                "model": model,
+                "messages": msgs,
+                "max_tokens": max_tokens,
+                "temperature": 0.65,
+            }
+            response = await self.client.post(
+                "https://openrouter.ai/api/v1/chat/completions",
+                headers={
+                    "Authorization": f"Bearer {settings.openrouter_api_key}",
+                    "Content-Type": "application/json",
+                },
+                json=final_payload,
+                timeout=15.0,
+            )
+            response.raise_for_status()
+            data = response.json()
+            latency_ms = (time.time() - start_time) * 1000
+            usage = data.get("usage", {})
+            if usage:
+                cost_tracker.record_llm_call(
+                    category=category,
+                    model=model,
+                    usage_data=usage,
+                    max_tokens=max_tokens,
+                    latency_ms=latency_ms,
+                    caller_name=caller_name,
+                )
+            content = data["choices"][0]["message"].get("content", "")
+            return content or "", all_tool_calls
+        except Exception as e:
+            print(f"[LLM-Tools] Final call failed: {e}")
+            return "", all_tool_calls
+
+    def _get_model_for_category(self, category: str) -> str:
+        """Get the best model for a given category based on config routing."""
+        return settings.category_models.get(category, self.openrouter_model)
+
+    async def _call_openrouter_with_fallback(self, messages: list[dict], max_tokens: Optional[int] = None, response_format: Optional[dict] = None, category: str = "unknown", caller_name: str = "", model_override: Optional[str] = None) -> str:
+        """Try category-specific model, then fallback models. Always returns a response."""
+
+        # Use explicit override if provided, else category routing, else primary
+        model = model_override or self._get_model_for_category(category)
+        result = await self._call_openrouter_once(messages, model, max_tokens=max_tokens, response_format=response_format, category=category, caller_name=caller_name)
+        if result is not None:
+            return result
+
+        # Try fallback models (drop response_format for fallbacks — not all models support it)
+        for model in FALLBACK_MODELS:
+            if model == self.openrouter_model:
+                continue  # Already tried
+            print(f"[LLM] Falling back to {model}...")
+            result = await self._call_openrouter_once(messages, model, timeout=8.0, max_tokens=max_tokens, category=category, caller_name=caller_name)
+            if result is not None:
+                return result
+
+        # Everything failed — return an in-character line so the show continues
+        print("[LLM] All models failed, using canned response")
+        return "Sorry, I totally blanked out for a second. What were you saying?"
+
+    async def _call_openrouter_once(self, messages: list[dict], model: str, timeout: float = 10.0, max_tokens: Optional[int] = None, response_format: Optional[dict] = None, category: str = "unknown", caller_name: str = "") -> str | None:
+        """Single attempt to call OpenRouter. Returns None on failure (not a fallback string)."""
+        start_time = time.time()
+        try:
+            payload = {
+                "model": model,
+                "messages": messages,
+                "max_tokens": max_tokens or 500,
+                "temperature": 0.65,
+                "top_p": 0.9,
+                "frequency_penalty": 0.3,
+                "presence_penalty": 0.15,
+            }
+            if response_format:
+                payload["response_format"] = response_format
+            response = await self.client.post(
+                "https://openrouter.ai/api/v1/chat/completions",
+                headers={
+                    "Authorization": f"Bearer {settings.openrouter_api_key}",
+                    "Content-Type": "application/json",
+                },
+                json=payload,
+                timeout=timeout,
+            )
+            response.raise_for_status()
+            data = response.json()
+            latency_ms = (time.time() - start_time) * 1000
+            usage = data.get("usage", {})
+            if usage:
+                cost_tracker.record_llm_call(
+                    category=category,
+                    model=model,
+                    usage_data=usage,
+                    max_tokens=max_tokens or 500,
+                    latency_ms=latency_ms,
+                    caller_name=caller_name,
+                )
+            content = data["choices"][0]["message"]["content"]
+            if content and content.strip():
+                return content
+            print(f"[LLM] {model} returned empty response")
+            return None
+        except httpx.TimeoutException:
+            print(f"[LLM] {model} timed out ({timeout}s)")
+            return None
+        except Exception as e:
+            print(f"[LLM] {model} error: {e}")
+            return None
+
+    async def _call_ollama(self, messages: list[dict], max_tokens: Optional[int] = None) -> str:
         """Call Ollama API"""
         try:
             async with httpx.AsyncClient() as client:
@@ -151,11 +385,11 @@ class LLMService:
                         "messages": messages,
                         "stream": False,
                         "options": {
-                            "num_predict": 100,     # Allow complete thoughts
-                            "temperature": 0.8,     # Balanced creativity/coherence
-                            "top_p": 0.9,           # Focused word choices
-                            "repeat_penalty": 1.3,  # Avoid repetition
-                            "top_k": 50,            # Reasonable token variety
+                            "num_predict": max_tokens or 100,
+                            "temperature": 0.8,
+                            "top_p": 0.9,
+                            "repeat_penalty": 1.3,
+                            "top_k": 50,
                         },
                     },
                     timeout=30.0
@@ -165,10 +399,10 @@ class LLMService:
                 return data["message"]["content"]
         except httpx.TimeoutException:
             print("Ollama timeout")
-            return "Uh, sorry, I lost you there for a second. What was that?"
+            return "Sorry, I totally blanked out for a second. What were you saying?"
         except Exception as e:
             print(f"Ollama error: {e}")
-            return "Yeah... I don't know, man."
+            return "Sorry, I totally blanked out for a second. What were you saying?"
 
 
 # Global instance

backend/services/news.py

@@ -0,0 +1,192 @@
+"""News service using local SearXNG for current events awareness in AI callers"""
+
+import asyncio
+import time
+import re
+from dataclasses import dataclass
+
+import httpx
+
+SEARXNG_URL = "http://localhost:8888"
+
+
+@dataclass
+class NewsItem:
+    title: str
+    source: str
+    published: str
+    content: str = ""
+
+
+class NewsService:
+    def __init__(self):
+        self._client: httpx.AsyncClient | None = None
+        self._headlines_cache: list[NewsItem] = []
+        self._headlines_ts: float = 0
+        self._search_cache: dict[str, tuple[float, list[NewsItem]]] = {}
+
+    @property
+    def client(self) -> httpx.AsyncClient:
+        if self._client is None or self._client.is_closed:
+            self._client = httpx.AsyncClient(timeout=5.0)
+        return self._client
+
+    async def get_headlines(self) -> list[NewsItem]:
+        # Cache for 30min
+        if self._headlines_cache and time.time() - self._headlines_ts < 1800:
+            return self._headlines_cache
+
+        try:
+            resp = await self.client.get(
+                f"{SEARXNG_URL}/search",
+                params={"q": "news", "format": "json", "categories": "news"},
+            )
+            resp.raise_for_status()
+            items = self._parse_searxng(resp.json(), max_items=10)
+            self._headlines_cache = items
+            self._headlines_ts = time.time()
+            return items
+        except Exception as e:
+            print(f"[News] Headlines fetch failed: {e}")
+            self._headlines_ts = time.time()
+            return self._headlines_cache
+
+    async def search_topic(self, query: str) -> list[NewsItem]:
+        cache_key = query.lower()
+
+        if cache_key in self._search_cache:
+            ts, items = self._search_cache[cache_key]
+            if time.time() - ts < 600:
+                return items
+
+        # Evict oldest when cache too large
+        if len(self._search_cache) > 50:
+            oldest_key = min(self._search_cache, key=lambda k: self._search_cache[k][0])
+            del self._search_cache[oldest_key]
+
+        try:
+            resp = await self.client.get(
+                f"{SEARXNG_URL}/search",
+                params={"q": query, "format": "json", "categories": "news"},
+            )
+            resp.raise_for_status()
+            items = self._parse_searxng(resp.json(), max_items=5)
+            self._search_cache[cache_key] = (time.time(), items)
+            return items
+        except Exception as e:
+            print(f"[News] Search failed for '{query}': {e}")
+            if cache_key in self._search_cache:
+                return self._search_cache[cache_key][1]
+            return []
+
+    def _parse_searxng(self, data: dict, max_items: int = 10) -> list[NewsItem]:
+        items = []
+        for result in data.get("results", [])[:max_items]:
+            title = result.get("title", "").strip()
+            if not title:
+                continue
+            # Extract source from engines list or metadata
+            engines = result.get("engines", [])
+            source = engines[0] if engines else ""
+            published = result.get("publishedDate", "")
+            content = result.get("content", "").strip()
+            items.append(NewsItem(title=title, source=source, published=published, content=content))
+        return items
+
+    def format_headlines_for_prompt(self, items: list[NewsItem]) -> str:
+        lines = []
+        for item in items:
+            if item.source:
+                lines.append(f"- {item.title} ({item.source})")
+            else:
+                lines.append(f"- {item.title}")
+        return "\n".join(lines)
+
+    async def close(self):
+        if self._client and not self._client.is_closed:
+            await self._client.aclose()
+
+
+STOP_WORDS = {
+    "the", "a", "an", "is", "are", "was", "were", "be", "been", "being",
+    "have", "has", "had", "do", "does", "did", "will", "would", "could",
+    "should", "may", "might", "shall", "can", "need", "dare", "ought",
+    "used", "to", "of", "in", "for", "on", "with", "at", "by", "from",
+    "as", "into", "through", "during", "before", "after", "above", "below",
+    "between", "out", "off", "over", "under", "again", "further", "then",
+    "once", "here", "there", "when", "where", "why", "how", "all", "both",
+    "each", "few", "more", "most", "other", "some", "such", "no", "nor",
+    "not", "only", "own", "same", "so", "than", "too", "very", "just",
+    "but", "and", "or", "if", "while", "because", "until", "about",
+    "that", "this", "these", "those", "what", "which", "who", "whom",
+    "it", "its", "he", "him", "his", "she", "her", "they", "them",
+    "their", "we", "us", "our", "you", "your", "me", "my", "i",
+    # Casual speech fillers
+    "yeah", "well", "like", "man", "dude", "okay", "right", "know",
+    "think", "mean", "really", "actually", "honestly", "basically",
+    "literally", "stuff", "thing", "things", "something", "anything",
+    "nothing", "everything", "someone", "anyone", "everyone", "nobody",
+    "gonna", "wanna", "gotta", "kinda", "sorta", "dunno",
+    "look", "see", "say", "said", "tell", "told", "talk", "talking",
+    "feel", "felt", "guess", "sure", "maybe", "probably", "never",
+    "always", "still", "even", "much", "many", "also", "got", "get",
+    "getting", "going", "come", "came", "make", "made", "take", "took",
+    "give", "gave", "want", "keep", "kept", "let", "put", "went",
+    "been", "being", "doing", "having", "call", "called", "calling",
+    "tonight", "today", "night", "time", "long", "good", "bad",
+    "first", "last", "back", "down", "ever", "away", "cant", "dont",
+    "didnt", "doesnt", "isnt", "wasnt", "wont", "wouldnt", "couldnt",
+    "shouldnt", "aint", "stop", "start", "started", "help",
+    # Radio show filler
+    "welcome", "thanks", "thank", "show", "roost", "luke", "whats",
+    "youre", "thats", "heres", "theyre", "ive", "youve", "weve",
+    "sounds", "listen", "hear", "heard", "happen", "happened",
+    "happening", "absolutely", "definitely", "exactly", "totally",
+    "pretty", "little", "whole", "every", "point", "sense", "real",
+    "great", "cool", "awesome", "amazing", "crazy", "weird", "funny",
+    "tough", "hard", "wrong", "true", "trying", "tried", "works",
+    "working", "anymore", "already", "enough", "though", "whatever",
+    "theres", "making", "saying", "keeping", "possible", "instead",
+    "front", "behind", "course", "talks", "happens", "watch",
+    "everybodys", "pants", "husband", "client",
+}
+
+
+def extract_keywords(text: str, max_keywords: int = 3) -> list[str]:
+    words = text.split()
+    if len(words) < 8:
+        return []  # Too short to extract meaningful topics
+
+    keywords = []
+
+    # Only look for proper nouns that are likely real topics (not caller names)
+    proper_nouns = []
+    for i, word in enumerate(words):
+        clean = re.sub(r'[^\w]', '', word)
+        if not clean or len(clean) < 3:
+            continue
+        is_sentence_start = i == 0 or (i > 0 and words[i - 1].rstrip()[-1:] in '.!?')
+        if clean[0].isupper() and not is_sentence_start and clean.lower() not in STOP_WORDS:
+            proper_nouns.append(clean)
+
+    # Only use proper nouns if we found 2+ (single one is probably a name)
+    if len(proper_nouns) >= 2:
+        for noun in proper_nouns[:max_keywords]:
+            if noun not in keywords:
+                keywords.append(noun)
+        if len(keywords) >= max_keywords:
+            return keywords
+
+    # Pass 2: uncommon words (>5 chars, not in stop words)
+    for word in words:
+        clean = re.sub(r'[^\w]', '', word).lower()
+        if len(clean) > 5 and clean not in STOP_WORDS:
+            if clean not in [k.lower() for k in keywords]:
+                keywords.append(clean)
+            if len(keywords) >= max_keywords:
+                return keywords
+
+    return keywords
+
+
+news_service = NewsService()

backend/services/regulars.py

@@ -0,0 +1,123 @@
+"""Returning caller persistence service"""
+
+import json
+import time
+import uuid
+from pathlib import Path
+from typing import Optional
+
+DATA_FILE = Path(__file__).parent.parent.parent / "data" / "regulars.json"
+MAX_REGULARS = 8
+
+
+class RegularCallerService:
+    """Manages persistent 'regular' callers who return across sessions"""
+
+    def __init__(self):
+        self._regulars: list[dict] = []
+        self._load()
+
+    def _load(self):
+        if DATA_FILE.exists():
+            try:
+                with open(DATA_FILE) as f:
+                    data = json.load(f)
+                self._regulars = data.get("regulars", [])
+                print(f"[Regulars] Loaded {len(self._regulars)} regular callers")
+            except Exception as e:
+                print(f"[Regulars] Failed to load: {e}")
+                self._regulars = []
+
+    def _save(self):
+        try:
+            DATA_FILE.parent.mkdir(parents=True, exist_ok=True)
+            with open(DATA_FILE, "w") as f:
+                json.dump({"regulars": self._regulars}, f, indent=2)
+        except Exception as e:
+            print(f"[Regulars] Failed to save: {e}")
+
+    def get_regulars(self) -> list[dict]:
+        return list(self._regulars)
+
+    def get_returning_callers(self, count: int = 2) -> list[dict]:
+        """Get up to `count` regulars for returning caller slots"""
+        import random
+        if not self._regulars:
+            return []
+        available = [r for r in self._regulars if len(r.get("call_history", [])) > 0]
+        if not available:
+            return []
+        return random.sample(available, min(count, len(available)))
+
+    def add_regular(self, name: str, gender: str, age: int, job: str,
+                    location: str, personality_traits: list[str],
+                    first_call_summary: str, voice: str = None,
+                    stable_seeds: dict = None,
+                    structured_background: dict = None,
+                    avatar: str = None) -> dict:
+        """Promote a first-time caller to regular"""
+        # Retire oldest if at cap
+        if len(self._regulars) >= MAX_REGULARS:
+            self._regulars.sort(key=lambda r: r.get("last_call", 0))
+            retired = self._regulars.pop(0)
+            print(f"[Regulars] Retired {retired['name']} to make room")
+
+        regular = {
+            "id": str(uuid.uuid4())[:8],
+            "name": name,
+            "gender": gender,
+            "age": age,
+            "job": job,
+            "location": location,
+            "personality_traits": personality_traits,
+            "voice": voice,
+            "stable_seeds": stable_seeds or {},
+            "structured_background": structured_background,
+            "avatar": avatar,
+            "relationships": {},
+            "call_history": [
+                {"summary": first_call_summary, "timestamp": time.time(),
+                 "arc_status": "ongoing"}
+            ],
+            "last_call": time.time(),
+            "created_at": time.time(),
+        }
+        self._regulars.append(regular)
+        self._save()
+        print(f"[Regulars] Promoted {name} to regular (total: {len(self._regulars)})")
+        return regular
+
+    def update_after_call(self, regular_id: str, call_summary: str,
+                          key_moments: list = None, arc_status: str = "ongoing"):
+        """Update a regular's history after a returning call"""
+        for regular in self._regulars:
+            if regular["id"] == regular_id:
+                entry = {
+                    "summary": call_summary,
+                    "timestamp": time.time(),
+                    "arc_status": arc_status,
+                }
+                if key_moments:
+                    entry["key_moments"] = key_moments
+                regular.setdefault("call_history", []).append(entry)
+                regular["last_call"] = time.time()
+                self._save()
+                print(f"[Regulars] Updated {regular['name']} call history ({len(regular['call_history'])} calls)")
+                return
+        print(f"[Regulars] Regular {regular_id} not found for update")
+
+    def add_relationship(self, regular_id: str, other_name: str,
+                         rel_type: str, context: str):
+        """Track a relationship between regulars"""
+        for regular in self._regulars:
+            if regular["id"] == regular_id:
+                regular.setdefault("relationships", {})[other_name] = {
+                    "type": rel_type,
+                    "context": context,
+                }
+                self._save()
+                print(f"[Regulars] {regular['name']} → {other_name}: {rel_type}")
+                return
+
+
+regular_caller_service = RegularCallerService()

backend/services/stem_recorder.py

@@ -0,0 +1,140 @@
+"""Records separate audio stems during a live show for post-production"""
+
+import time
+import threading
+import numpy as np
+import soundfile as sf
+from pathlib import Path
+from collections import deque
+
+STEM_NAMES = ["host", "caller", "devon", "music", "sfx", "ads", "idents"]
+
+
+class StemRecorder:
+    def __init__(self, output_dir: str | Path, sample_rate: int = 48000):
+        self.output_dir = Path(output_dir)
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+        self.sample_rate = sample_rate
+        self._running = False
+        self._queues: dict[str, deque] = {}
+        self._writer_thread: threading.Thread | None = None
+        self._start_time: float = 0.0
+        self._write_errors: int = 0
+
+    def start(self):
+        self._start_time = time.time()
+        self._running = True
+        self._write_errors = 0
+        for name in STEM_NAMES:
+            self._queues[name] = deque()
+        self._writer_thread = threading.Thread(target=self._writer_loop, daemon=False)
+        self._writer_thread.start()
+        print(f"[StemRecorder] Recording started -> {self.output_dir}")
+
+    def write(self, stem_name: str, audio_data: np.ndarray, source_sr: int):
+        """Non-blocking write for continuous streams (host mic, music, ads).
+        Safe to call from audio callbacks."""
+        if not self._running or stem_name not in self._queues:
+            return
+        self._queues[stem_name].append(("audio", audio_data.copy(), source_sr))
+
+    def write_sporadic(self, stem_name: str, audio_data: np.ndarray, source_sr: int):
+        """Write for burst sources (caller TTS, SFX). Pads silence to current time."""
+        if not self._running or stem_name not in self._queues:
+            return
+        self._queues[stem_name].append(("sporadic", audio_data.copy(), source_sr))
+
+    def _resample(self, audio_data: np.ndarray, source_sr: int) -> np.ndarray:
+        if source_sr == self.sample_rate:
+            return audio_data.astype(np.float32)
+        ratio = self.sample_rate / source_sr
+        num_samples = int(len(audio_data) * ratio)
+        if num_samples <= 0:
+            return np.array([], dtype=np.float32)
+        indices = (np.arange(num_samples) / ratio).astype(int)
+        indices = np.clip(indices, 0, len(audio_data) - 1)
+        return audio_data[indices].astype(np.float32)
+
+    def _writer_loop(self):
+        """Background thread that drains queues and writes to WAV files."""
+        files: dict[str, sf.SoundFile] = {}
+        positions: dict[str, int] = {}
+
+        for name in STEM_NAMES:
+            path = self.output_dir / f"{name}.wav"
+            files[name] = sf.SoundFile(
+                str(path), mode="w",
+                samplerate=self.sample_rate,
+                channels=1, subtype="FLOAT",
+            )
+            positions[name] = 0
+
+        try:
+            while self._running or any(len(q) > 0 for q in self._queues.values()):
+                did_work = False
+                for name in STEM_NAMES:
+                    q = self._queues[name]
+                    while q:
+                        did_work = True
+                        msg_type, audio_data, source_sr = q.popleft()
+                        resampled = self._resample(audio_data, source_sr)
+                        if len(resampled) == 0:
+                            continue
+
+                        try:
+                            if msg_type == "sporadic":
+                                elapsed = time.time() - self._start_time
+                                expected_pos = int(elapsed * self.sample_rate)
+                                if expected_pos > positions[name]:
+                                    gap = expected_pos - positions[name]
+                                    files[name].write(np.zeros(gap, dtype=np.float32))
+                                    positions[name] = expected_pos
+
+                            files[name].write(resampled)
+                            positions[name] += len(resampled)
+                        except Exception as e:
+                            self._write_errors += 1
+                            if self._write_errors <= 5:
+                                print(f"[StemRecorder] Write error on {name}: {e}")
+                            elif self._write_errors == 6:
+                                print(f"[StemRecorder] Suppressing further write errors")
+
+                if not did_work:
+                    time.sleep(0.02)
+
+            # Pad all stems to same length
+            max_pos = max(positions.values()) if positions else 0
+            for name in STEM_NAMES:
+                try:
+                    if positions[name] < max_pos:
+                        files[name].write(np.zeros(max_pos - positions[name], dtype=np.float32))
+                except Exception as e:
+                    print(f"[StemRecorder] Final pad error on {name}: {e}")
+        finally:
+            for name, f in files.items():
+                try:
+                    f.close()
+                except Exception as e:
+                    print(f"[StemRecorder] Error closing {name}.wav: {e}")
+
+        total_errors = self._write_errors
+        err_msg = f", {total_errors} write errors" if total_errors else ""
+        print(f"[StemRecorder] Writer done. {max_pos} samples ({max_pos / self.sample_rate:.1f}s{err_msg})")
+
+    def stop(self) -> dict[str, str]:
+        if not self._running:
+            return {}
+
+        self._running = False
+        if self._writer_thread:
+            self._writer_thread.join(timeout=30.0)
+            if self._writer_thread.is_alive():
+                print("[StemRecorder] Warning: writer thread still running after 30s")
+            self._writer_thread = None
+
+        paths = {}
+        for name in STEM_NAMES:
+            paths[name] = str(self.output_dir / f"{name}.wav")
+
+        self._queues.clear()
+        return paths

backend/services/transcription.py

@@ -5,6 +5,8 @@ import numpy as np
 from faster_whisper import WhisperModel
 import librosa
 
+WHISPER_MODEL = "distil-large-v3"
+
 # Global model instance (loaded once)
 _whisper_model = None
 
@@ -13,10 +15,8 @@ def get_whisper_model() -> WhisperModel:
     """Get or create Whisper model instance"""
     global _whisper_model
     if _whisper_model is None:
-        print("Loading Whisper tiny model for fast transcription...")
-        # Use tiny model for speed - about 3-4x faster than base
-        # beam_size=1 and best_of=1 for fastest inference
-        _whisper_model = WhisperModel("tiny", device="cpu", compute_type="int8")
+        print(f"Loading Whisper {WHISPER_MODEL} model...")
+        _whisper_model = WhisperModel(WHISPER_MODEL, device="cpu", compute_type="int8")
         print("Whisper model loaded")
     return _whisper_model
 
@@ -67,13 +67,15 @@ def decode_audio(audio_data: bytes, source_sample_rate: int = None) -> tuple[np.
         return audio, 16000
 
 
-async def transcribe_audio(audio_data: bytes, source_sample_rate: int = None) -> str:
+async def transcribe_audio(audio_data: bytes, source_sample_rate: int = None,
+                           context_hint: str = "") -> str:
     """
     Transcribe audio data to text using Whisper.
 
     Args:
         audio_data: Audio bytes (webm, ogg, wav, or raw PCM)
         source_sample_rate: If provided, treat audio_data as raw PCM at this rate
+        context_hint: Optional extra context for the initial prompt (e.g. caller name/topic)
 
     Returns:
         Transcribed text
@@ -100,13 +102,18 @@ async def transcribe_audio(audio_data: bytes, source_sample_rate: int = None) ->
     else:
         audio_16k = audio
 
-    # Transcribe with speed optimizations
+    # Build initial prompt — context helps Whisper with names and topic-specific words
+    initial_prompt = "Luke at the Roost, a late-night radio talk show in New Mexico. The host Luke talks to callers about life, relationships, sports, politics, and pop culture."
+    if context_hint:
+        initial_prompt += f" {context_hint}"
+
+    # Transcribe
     segments, info = model.transcribe(
         audio_16k,
-        beam_size=1,  # Faster, slightly less accurate
-        best_of=1,
-        language="en",  # Skip language detection
-        vad_filter=True,  # Skip silence
+        beam_size=5,
+        language="en",
+        vad_filter=True,
+        initial_prompt=initial_prompt,
     )
     segments_list = list(segments)
     text = " ".join([s.text for s in segments_list]).strip()

backend/services/tts.py

@@ -8,6 +8,7 @@ import tempfile
 import torch
 
 from ..config import settings
+from .cost_tracker import cost_tracker
 
 # Patch torch.load for compatibility with PyTorch 2.6+
 _original_torch_load = torch.load
@@ -82,25 +83,137 @@ VITS_SPEAKERS = {
 DEFAULT_VITS_SPEAKER = "p225"
 
 # Inworld voice mapping - maps ElevenLabs voice IDs to Inworld voices
-# Full voice list from API: Alex, Ashley, Blake, Carter, Clive, Craig, Deborah,
-# Dennis, Dominus, Edward, Elizabeth, Hades, Hana, Julia, Luna, Mark, Olivia,
-# Pixie, Priya, Ronald, Sarah, Shaun, Theodore, Timothy, Wendy
+# Full voice list from API (English): Abby, Alex, Amina, Anjali, Arjun, Ashley,
+# Blake, Brian, Callum, Carter, Celeste, Chloe, Claire, Clive, Craig, Darlene,
+# Deborah, Dennis, Derek, Dominus, Edward, Elizabeth, Elliot, Ethan, Evan, Evelyn,
+# Gareth, Graham, Grant, Hades, Hamish, Hana, Hank, Jake, James, Jason, Jessica,
+# Julia, Kayla, Kelsey, Lauren, Liam, Loretta, Luna, Malcolm, Mark, Marlene,
+# Miranda, Mortimer, Nate, Oliver, Olivia, Pippa, Pixie, Priya, Ronald, Rupert,
+# Saanvi, Sarah, Sebastian, Serena, Shaun, Simon, Snik, Tessa, Theodore, Timothy,
+# Tyler, Veronica, Victor, Victoria, Vinny, Wendy
 INWORLD_VOICES = {
-    # Male voices - each caller gets a unique voice matching their personality
+    # Original voice IDs
     "VR6AewLTigWG4xSOukaG": "Edward",    # Tony - fast-talking, emphatic, streetwise
     "TxGEqnHWrfWFTfGW9XjX": "Shaun",     # Rick - friendly, dynamic, conversational
     "pNInz6obpgDQGcFmaJgB": "Alex",      # Dennis - energetic, expressive, mildly nasal
     "ODq5zmih8GrVes37Dizd": "Craig",     # Earl - older British, refined, articulate
-    "IKne3meq5aSn9XLyUdCD": "Timothy",   # Marcus - lively, upbeat American
-    # Female voices - each caller gets a unique voice matching their personality
+    "IKne3meq5aSn9XLyUdCD": "Timothy",   # Marcus/Jerome - lively, upbeat American
     "jBpfuIE2acCO8z3wKNLl": "Hana",      # Jasmine - bright, expressive young female
     "EXAVITQu4vr4xnSDxMaL": "Ashley",    # Megan - warm, natural female
     "21m00Tcm4TlvDq8ikWAM": "Wendy",     # Tanya - posh, middle-aged British
     "XB0fDUnXU5powFXDhCwa": "Sarah",     # Carla - fast-talking, questioning tone
-    "pFZP5JQG7iQjIQuC4Bku": "Deborah",   # Brenda - gentle, elegant
+    "pFZP5JQG7iQjIQuC4Bku": "Deborah",   # Brenda (original) - gentle, elegant
+    # Regular caller voice IDs (backfilled)
+    "onwK4e9ZLuTAKqWW03F9": "Ronald",    # Bobby - repo man
+    "FGY2WhTYpPnrIDTdsKH5": "Julia",     # Carla (regular) - Jersey mom
+    "CwhRBWXzGAHq8TQ4Fs17": "Mark",      # Leon - male caller
+    "SOYHLrjzK2X1ezoPC6cr": "Carter",    # Carl - male caller
+    "N2lVS1w4EtoT3dr4eOWO": "Clive",     # Reggie - male caller
+    "hpp4J3VqNfWAUOO0d1Us": "Olivia",    # Brenda (regular) - ambulance driver
+    "nPczCjzI2devNBz1zQrb": "Theodore",  # Keith - male caller
+    "JBFqnCBsd6RMkjVDRZzb": "Blake",     # Andre - male caller
+    "TX3LPaxmHKxFdv7VOQHJ": "Dennis",    # Rick (regular) - male caller
+    "cgSgspJ2msm6clMCkdW9": "Priya",     # Megan (regular) - female caller
 }
 DEFAULT_INWORLD_VOICE = "Dennis"
 
+# Inworld voices that speak too slowly at default rate — bump them up
+# Range is 0.5 to 1.5, where 1.0 is the voice's native speed
+INWORLD_SPEED_OVERRIDES = {
+    "Wendy": 1.15,
+    "Craig": 1.15,
+    "Deborah": 1.15,
+    "Sarah": 1.1,
+    "Hana": 1.1,
+    "Theodore": 1.15,
+    "Blake": 1.1,
+    "Priya": 1.1,
+}
+DEFAULT_INWORLD_SPEED = 1.1  # Slight bump for all voices
+
+# Voice profiles — perceptual dimensions for each Inworld voice.
+# Used by style-to-voice matching to pair caller personalities with fitting voices.
+# weight: vocal depth/richness (light, medium, heavy)
+# energy: default speaking animation (low, medium, high)
+# warmth: friendliness/openness in the voice (cool, neutral, warm)
+# age_feel: perceived speaker age (young, middle, mature)
+VOICE_PROFILES = {
+    # --- Male voices ---
+    # Known characterizations from INWORLD_VOICES mapping and usage
+    "Alex":      {"weight": "light",  "energy": "high",   "warmth": "warm",    "age_feel": "young"},    # energetic, expressive, mildly nasal
+    "Edward":    {"weight": "medium", "energy": "high",   "warmth": "neutral", "age_feel": "middle"},   # fast-talking, emphatic, streetwise
+    "Shaun":     {"weight": "medium", "energy": "high",   "warmth": "warm",    "age_feel": "middle"},   # friendly, dynamic, conversational
+    "Craig":     {"weight": "heavy",  "energy": "low",    "warmth": "cool",    "age_feel": "mature"},   # older British, refined, articulate
+    "Timothy":   {"weight": "light",  "energy": "high",   "warmth": "warm",    "age_feel": "young"},    # lively, upbeat American
+    "Dennis":    {"weight": "medium", "energy": "high",   "warmth": "warm",    "age_feel": "middle"},   # energetic, default voice
+    "Ronald":    {"weight": "heavy",  "energy": "medium", "warmth": "neutral", "age_feel": "mature"},   # gruff, authoritative
+    "Theodore":  {"weight": "heavy",  "energy": "low",    "warmth": "warm",    "age_feel": "mature"},   # slow, deliberate
+    "Blake":     {"weight": "medium", "energy": "medium", "warmth": "neutral", "age_feel": "middle"},
+    "Carter":    {"weight": "medium", "energy": "medium", "warmth": "neutral", "age_feel": "middle"},
+    "Clive":     {"weight": "heavy",  "energy": "low",    "warmth": "cool",    "age_feel": "mature"},
+    "Mark":      {"weight": "medium", "energy": "medium", "warmth": "neutral", "age_feel": "middle"},
+    "Sebastian": {"weight": "medium", "energy": "medium", "warmth": "cool",    "age_feel": "middle"},   # used by Silas (cult leader) & Chip
+    "Elliot":    {"weight": "light",  "energy": "medium", "warmth": "warm",    "age_feel": "young"},    # used by Otis (comedian)
+    # Remaining male pool voices
+    "Arjun":     {"weight": "medium", "energy": "medium", "warmth": "warm",    "age_feel": "middle"},
+    "Brian":     {"weight": "medium", "energy": "medium", "warmth": "warm",    "age_feel": "middle"},
+    "Callum":    {"weight": "medium", "energy": "medium", "warmth": "neutral", "age_feel": "young"},
+    "Derek":     {"weight": "medium", "energy": "medium", "warmth": "neutral", "age_feel": "middle"},
+    "Ethan":     {"weight": "medium", "energy": "medium", "warmth": "warm",    "age_feel": "young"},
+    "Evan":      {"weight": "light",  "energy": "medium", "warmth": "neutral", "age_feel": "young"},
+    "Gareth":    {"weight": "medium", "energy": "medium", "warmth": "neutral", "age_feel": "middle"},
+    "Graham":    {"weight": "heavy",  "energy": "low",    "warmth": "neutral", "age_feel": "mature"},
+    "Grant":     {"weight": "medium", "energy": "medium", "warmth": "neutral", "age_feel": "middle"},
+    "Hades":     {"weight": "heavy",  "energy": "low",    "warmth": "cool",    "age_feel": "mature"},
+    "Hamish":    {"weight": "medium", "energy": "medium", "warmth": "warm",    "age_feel": "middle"},
+    "Hank":      {"weight": "heavy",  "energy": "medium", "warmth": "warm",    "age_feel": "mature"},
+    "Jake":      {"weight": "medium", "energy": "high",   "warmth": "warm",    "age_feel": "young"},
+    "James":     {"weight": "medium", "energy": "medium", "warmth": "neutral", "age_feel": "middle"},
+    "Jason":     {"weight": "medium", "energy": "medium", "warmth": "neutral", "age_feel": "middle"},
+    "Liam":      {"weight": "medium", "energy": "high",   "warmth": "warm",    "age_feel": "young"},
+    "Malcolm":   {"weight": "heavy",  "energy": "low",    "warmth": "cool",    "age_feel": "mature"},
+    "Mortimer":  {"weight": "heavy",  "energy": "low",    "warmth": "cool",    "age_feel": "mature"},
+    "Nate":      {"weight": "light",  "energy": "high",   "warmth": "warm",    "age_feel": "young"},
+    "Oliver":    {"weight": "medium", "energy": "medium", "warmth": "warm",    "age_feel": "middle"},
+    "Rupert":    {"weight": "medium", "energy": "low",    "warmth": "cool",    "age_feel": "mature"},
+    "Simon":     {"weight": "medium", "energy": "medium", "warmth": "neutral", "age_feel": "middle"},
+    "Tyler":     {"weight": "light",  "energy": "high",   "warmth": "neutral", "age_feel": "young"},
+    "Victor":    {"weight": "heavy",  "energy": "medium", "warmth": "cool",    "age_feel": "mature"},
+    "Vinny":     {"weight": "medium", "energy": "high",   "warmth": "warm",    "age_feel": "middle"},
+    # --- Female voices ---
+    # Known characterizations
+    "Hana":      {"weight": "light",  "energy": "high",   "warmth": "warm",    "age_feel": "young"},    # bright, expressive young
+    "Ashley":    {"weight": "medium", "energy": "medium", "warmth": "warm",    "age_feel": "middle"},   # warm, natural
+    "Wendy":     {"weight": "medium", "energy": "low",    "warmth": "cool",    "age_feel": "mature"},   # posh, middle-aged British
+    "Sarah":     {"weight": "light",  "energy": "high",   "warmth": "neutral", "age_feel": "middle"},   # fast-talking, questioning
+    "Deborah":   {"weight": "medium", "energy": "low",    "warmth": "warm",    "age_feel": "mature"},   # gentle, elegant
+    "Olivia":    {"weight": "medium", "energy": "medium", "warmth": "warm",    "age_feel": "middle"},
+    "Julia":     {"weight": "medium", "energy": "medium", "warmth": "neutral", "age_feel": "middle"},   # used by Angie (deadpan)
+    "Priya":     {"weight": "light",  "energy": "medium", "warmth": "warm",    "age_feel": "young"},
+    "Amina":     {"weight": "medium", "energy": "medium", "warmth": "warm",    "age_feel": "middle"},   # used by Charlene (bragger)
+    "Tessa":     {"weight": "medium", "energy": "medium", "warmth": "warm",    "age_feel": "middle"},   # used by Lucille
+    "Kelsey":    {"weight": "light",  "energy": "medium", "warmth": "neutral", "age_feel": "young"},    # used by Maxine (quiet/nervous)
+    # Remaining female pool voices
+    "Anjali":    {"weight": "light",  "energy": "medium", "warmth": "warm",    "age_feel": "young"},
+    "Celeste":   {"weight": "light",  "energy": "medium", "warmth": "cool",    "age_feel": "middle"},
+    "Chloe":     {"weight": "light",  "energy": "high",   "warmth": "warm",    "age_feel": "young"},
+    "Claire":    {"weight": "medium", "energy": "medium", "warmth": "neutral", "age_feel": "middle"},
+    "Darlene":   {"weight": "medium", "energy": "medium", "warmth": "warm",    "age_feel": "mature"},
+    "Elizabeth":  {"weight": "medium", "energy": "medium", "warmth": "cool",    "age_feel": "mature"},
+    "Jessica":   {"weight": "medium", "energy": "medium", "warmth": "warm",    "age_feel": "middle"},
+    "Kayla":     {"weight": "light",  "energy": "high",   "warmth": "warm",    "age_feel": "young"},
+    "Lauren":    {"weight": "medium", "energy": "medium", "warmth": "neutral", "age_feel": "middle"},
+    "Loretta":   {"weight": "medium", "energy": "low",    "warmth": "warm",    "age_feel": "mature"},
+    "Luna":      {"weight": "light",  "energy": "medium", "warmth": "warm",    "age_feel": "young"},
+    "Marlene":   {"weight": "medium", "energy": "low",    "warmth": "neutral", "age_feel": "mature"},
+    "Miranda":   {"weight": "medium", "energy": "medium", "warmth": "cool",    "age_feel": "middle"},
+    "Pippa":     {"weight": "light",  "energy": "high",   "warmth": "warm",    "age_feel": "young"},
+    "Saanvi":    {"weight": "light",  "energy": "medium", "warmth": "warm",    "age_feel": "young"},
+    "Serena":    {"weight": "medium", "energy": "medium", "warmth": "cool",    "age_feel": "middle"},
+    "Veronica":  {"weight": "medium", "energy": "medium", "warmth": "cool",    "age_feel": "middle"},
+    "Victoria":  {"weight": "medium", "energy": "low",    "warmth": "cool",    "age_feel": "mature"},
+}
+
 
 def preprocess_text_for_kokoro(text: str) -> str:
     """
@@ -571,19 +684,52 @@ async def generate_speech_chattts(text: str, voice_id: str) -> tuple[np.ndarray,
     return audio.astype(np.float32), 24000
 
 
+_EXCITED_KEYWORDS = {"excited", "amazing", "incredible", "can't believe", "so happy",
+                     "hell yeah", "fired up", "furious", "pissed", "angry", "what the hell",
+                     "are you kidding", "unbelievable", "!!", "oh my god"}
+_SAD_KEYWORDS = {"sad", "miss them", "passed away", "funeral", "crying", "broke my heart",
+                 "can't stop thinking", "lonely", "depressed", "sorry", "regret",
+                 "wish I could", "never got to", "lost", "grief"}
+
+
+def _detect_speech_rate(text: str, base_speed: float) -> float:
+    """Adjust speech rate based on emotional content of the text.
+    Returns a speed value clamped to Inworld's 0.5-1.5 range."""
+    text_lower = text.lower()
+    excited = sum(1 for kw in _EXCITED_KEYWORDS if kw in text_lower)
+    sad = sum(1 for kw in _SAD_KEYWORDS if kw in text_lower)
+
+    if excited >= 2:
+        return min(1.5, base_speed + 0.15)
+    elif excited >= 1:
+        return min(1.5, base_speed + 0.08)
+    elif sad >= 2:
+        return max(0.5, base_speed - 0.2)
+    elif sad >= 1:
+        return max(0.5, base_speed - 0.1)
+    return base_speed
+
+
 async def generate_speech_inworld(text: str, voice_id: str) -> tuple[np.ndarray, int]:
     """Generate speech using Inworld TTS API (high quality, natural voices)"""
     import httpx
     import base64
     import librosa
 
-    voice = INWORLD_VOICES.get(voice_id, DEFAULT_INWORLD_VOICE)
+    # voice_id is now the Inworld voice name directly (e.g. "Edward")
+    # Fall back to legacy mapping if it's an ElevenLabs ID
+    if voice_id in INWORLD_VOICES:
+        voice = INWORLD_VOICES[voice_id]
+    else:
+        voice = voice_id
 
     api_key = settings.inworld_api_key
     if not api_key:
         raise RuntimeError("INWORLD_API_KEY not set in environment")
 
-    print(f"[Inworld TTS] Voice: {voice}, Text: {text[:50]}...")
+    base_speed = INWORLD_SPEED_OVERRIDES.get(voice, DEFAULT_INWORLD_SPEED)
+    speed = _detect_speech_rate(text, base_speed)
+    print(f"[Inworld TTS] Voice: {voice}, Speed: {speed:.2f} (base {base_speed}), Text: {text[:50]}...")
 
     url = "https://api.inworld.ai/tts/v1/voice"
     headers = {
@@ -592,15 +738,16 @@ async def generate_speech_inworld(text: str, voice_id: str) -> tuple[np.ndarray,
     }
     payload = {
         "text": text,
-        "voice_id": voice,
-        "model_id": "inworld-tts-1.5-mini",
-        "audio_config": {
-            "encoding": "LINEAR16",
-            "sample_rate_hertz": 48000,
+        "voiceId": voice,
+        "modelId": "inworld-tts-1.5-max",
+        "audioConfig": {
+            "audioEncoding": "LINEAR16",
+            "sampleRateHertz": 48000,
+            "speakingRate": speed,
         },
     }
 
-    async with httpx.AsyncClient(timeout=60.0) as client:
+    async with httpx.AsyncClient(timeout=12.0) as client:
         response = await client.post(url, json=payload, headers=headers)
         response.raise_for_status()
         data = response.json()
@@ -635,47 +782,89 @@ async def generate_speech_inworld(text: str, voice_id: str) -> tuple[np.ndarray,
     return audio.astype(np.float32), 24000
 
 
+def pick_caller_tts_provider() -> str | None:
+    """Randomly assign a TTS provider for a caller.
+    Returns None to use the global default, or a specific provider name.
+    ~70% inworld (default), ~20% kokoro, ~10% other available."""
+    import random
+    roll = random.random()
+    if roll < 0.70:
+        return None  # Use global default (typically inworld)
+    elif roll < 0.90:
+        return "kokoro"
+    else:
+        return random.choice(["kokoro", "f5tts", "chattts"])
+
+
+_TTS_PROVIDERS = {
+    "kokoro": lambda text, vid: generate_speech_kokoro(text, vid),
+    "f5tts": lambda text, vid: generate_speech_f5tts(text, vid),
+    "inworld": lambda text, vid: generate_speech_inworld(text, vid),
+    "chattts": lambda text, vid: generate_speech_chattts(text, vid),
+    "styletts2": lambda text, vid: generate_speech_styletts2(text, vid),
+    "bark": lambda text, vid: generate_speech_bark(text, vid),
+    "vits": lambda text, vid: generate_speech_vits(text, vid),
+    "elevenlabs": lambda text, vid: generate_speech_elevenlabs(text, vid),
+}
+
+TTS_MAX_RETRIES = 2
+TTS_RETRY_DELAYS = [0.5, 1.0]  # seconds between retries
+
+
 async def generate_speech(
     text: str,
     voice_id: str,
     phone_quality: str = "normal",
-    apply_filter: bool = True
+    apply_filter: bool = True,
+    provider_override: str = None
 ) -> bytes:
     """
-    Generate speech from text.
+    Generate speech from text with automatic retry on failure.
 
     Args:
         text: Text to speak
         voice_id: ElevenLabs voice ID (mapped to local voice if using local TTS)
         phone_quality: Quality of phone filter ("none" to disable)
         apply_filter: Whether to apply phone filter
+        provider_override: Override the global TTS provider for this call
 
     Returns:
         Raw PCM audio bytes (16-bit signed int, 24kHz)
     """
-    # Choose TTS provider
-    provider = settings.tts_provider
-    print(f"[TTS] Provider: {provider}, Text: {text[:50]}...")
+    import asyncio
 
-    if provider == "kokoro":
-        audio, sample_rate = await generate_speech_kokoro(text, voice_id)
-    elif provider == "f5tts":
-        audio, sample_rate = await generate_speech_f5tts(text, voice_id)
-    elif provider == "inworld":
-        audio, sample_rate = await generate_speech_inworld(text, voice_id)
-    elif provider == "chattts":
-        audio, sample_rate = await generate_speech_chattts(text, voice_id)
-    elif provider == "styletts2":
-        audio, sample_rate = await generate_speech_styletts2(text, voice_id)
-    elif provider == "bark":
-        audio, sample_rate = await generate_speech_bark(text, voice_id)
-    elif provider == "vits":
-        audio, sample_rate = await generate_speech_vits(text, voice_id)
-    elif provider == "elevenlabs":
-        audio, sample_rate = await generate_speech_elevenlabs(text, voice_id)
-    else:
+    provider = provider_override or settings.tts_provider
+    print(f"[TTS] Provider: {provider}{' (override)' if provider_override else ''}, Text: {text[:50]}...")
+
+    gen_fn = _TTS_PROVIDERS.get(provider)
+    if not gen_fn:
         raise ValueError(f"Unknown TTS provider: {provider}")
 
+    last_error = None
+    try:
+        async with asyncio.timeout(20):
+            for attempt in range(TTS_MAX_RETRIES):
+                try:
+                    audio, sample_rate = await gen_fn(text, voice_id)
+                    cost_tracker.record_tts_call(provider, voice_id, len(text))
+                    if attempt > 0:
+                        print(f"[TTS] Succeeded on retry {attempt}")
+                    break
+                except TimeoutError:
+                    raise  # Let asyncio.timeout propagate
+                except Exception as e:
+                    last_error = e
+                    if attempt < TTS_MAX_RETRIES - 1:
+                        delay = TTS_RETRY_DELAYS[attempt]
+                        print(f"[TTS] {provider} attempt {attempt + 1} failed: {e} — retrying in {delay}s...")
+                        await asyncio.sleep(delay)
+                    else:
+                        print(f"[TTS] {provider} failed after {TTS_MAX_RETRIES} attempts: {e}")
+                        raise
+    except TimeoutError:
+        print(f"[TTS] Overall timeout (20s) for {provider}")
+        raise RuntimeError(f"TTS generation timed out after 20s")
+
     # Apply phone filter if requested
     # Skip filter for Bark - it already has rough audio quality
     if apply_filter and phone_quality not in ("none", "studio") and provider != "bark":

backup.sh

@@ -0,0 +1,58 @@
+#!/bin/bash
+# Daily backup of critical AI podcast data to NAS
+# Backs up: Castopod MariaDB dump, local data/ directory, publish state
+#
+# Usage: ./backup.sh
+# Cron:  0 3 * * * /Users/lukemacneil/code/ai-podcast/backup.sh >> /tmp/ai-podcast-backup.log 2>&1
+
+set -euo pipefail
+
+NAS_HOST="mmgnas"
+NAS_USER="luke"
+NAS_PORT="8001"
+DOCKER_BIN="/share/CACHEDEV1_DATA/.qpkg/container-station/bin/docker"
+BACKUP_BASE="/share/CACHEDEV1_DATA/backups/ai-podcast"
+PROJECT_DIR="/Users/lukemacneil/code/ai-podcast"
+DATE=$(date +%Y-%m-%d)
+KEEP_DAYS=14
+
+echo "$(date -u '+%Y-%m-%dT%H:%M:%SZ') Starting backup..."
+
+# 1. Dump Castopod MariaDB on NAS
+echo "  Dumping MariaDB..."
+ssh -p "$NAS_PORT" "$NAS_USER@$NAS_HOST" \
+    "$DOCKER_BIN exec castopod-mariadb-1 mysqldump -u castopod --password=\$(cat /run/secrets/db_password 2>/dev/null || echo BYtbFfk3ndeVabb26xb0UyKU) castopod" \
+    > "/tmp/castopod-db-${DATE}.sql" 2>/dev/null
+
+if [ -s "/tmp/castopod-db-${DATE}.sql" ]; then
+    gzip -f "/tmp/castopod-db-${DATE}.sql"
+    scp -P "$NAS_PORT" "/tmp/castopod-db-${DATE}.sql.gz" \
+        "$NAS_USER@$NAS_HOST:$BACKUP_BASE/castopod-db-${DATE}.sql.gz"
+    rm -f "/tmp/castopod-db-${DATE}.sql.gz"
+    echo "  MariaDB dump: OK"
+else
+    echo "  WARNING: MariaDB dump is empty or failed"
+fi
+
+# 2. Sync data/ directory to NAS (rsync for efficiency)
+echo "  Syncing data/ directory..."
+rsync -az --delete \
+    -e "ssh -p $NAS_PORT" \
+    "$PROJECT_DIR/data/" \
+    "$NAS_USER@$NAS_HOST:$BACKUP_BASE/data/"
+echo "  data/ sync: OK"
+
+# 3. Backup .env (contains API keys — critical for disaster recovery)
+echo "  Backing up .env..."
+scp -P "$NAS_PORT" "$PROJECT_DIR/.env" \
+    "$NAS_USER@$NAS_HOST:$BACKUP_BASE/env-${DATE}.bak"
+echo "  .env backup: OK"
+
+# 4. Prune old backups
+echo "  Pruning backups older than ${KEEP_DAYS} days..."
+ssh -p "$NAS_PORT" "$NAS_USER@$NAS_HOST" \
+    "find $BACKUP_BASE -name 'castopod-db-*.sql.gz' -mtime +${KEEP_DAYS} -delete 2>/dev/null; \
+     find $BACKUP_BASE -name 'env-*.bak' -mtime +${KEEP_DAYS} -delete 2>/dev/null"
+echo "  Prune: OK"
+
+echo "$(date -u '+%Y-%m-%dT%H:%M:%SZ') Backup complete."

data/emails.json

@@ -0,0 +1,3 @@
+{
+  "emails": []
+}

data/intern.json

@@ -0,0 +1,834 @@
+{
+  "lookup_history": [
+    {
+      "question": "what time is it",
+      "answer": "It's three oh three AM. Saturday morning.",
+      "tools_used": [
+        "get_current_time"
+      ],
+      "timestamp": 1773479014.367399
+    },
+    {
+      "question": "what time is it",
+      "answer": "...yeah, it's three ten AM. Saturday morning.",
+      "tools_used": [
+        "get_current_time"
+      ],
+      "timestamp": 1773479441.184032
+    },
+    {
+      "question": "(interjection)",
+      "answer": "Um, so I don't know if this helps but... in a lot of states there's actually mandatory arrest laws for domestic violence calls. Like, if there's visible injury or probable cause, the officer doesn't r",
+      "tools_used": [
+        "web_search"
+      ],
+      "timestamp": 1773483367.819699
+    },
+    {
+      "question": "(interjection)",
+      "answer": "...yeah, so that was the Brian Wells case. Pizza delivery guy in Erie, Pennsylvania, 2003. He robbed a bank with a bomb collar locked around his neck and it went off when the cops got him. The whole t",
+      "tools_used": [
+        "web_search",
+        "wikipedia_lookup"
+      ],
+      "timestamp": 1773484350.1126778
+    },
+    {
+      "question": "(interjection)",
+      "answer": "Um, so I tried to look up the fraternization rules but the search isn't working right now. But I'm pretty sure that's like, super against regulations. Recruiters aren't supposed to have personal relat",
+      "tools_used": [
+        "web_search",
+        "web_search"
+      ],
+      "timestamp": 1773486225.436269
+    },
+    {
+      "question": "(interjection)",
+      "answer": "...yeah, so I was trying to look up the actual regulation number but the internet's being weird right now. But I'm like ninety percent sure there's a specific army reg that covers recruiter-recruit re",
+      "tools_used": [
+        "web_search"
+      ],
+      "timestamp": 1773486326.583227
+    },
+    {
+      "question": "(interjection)",
+      "answer": "...yeah, sorry, the internet's definitely down. I was trying to get the actual reg number and the reporting hotline but nothing's loading. I think it's an issue on our end, not me, but... yeah. Sorry.",
+      "tools_used": [
+        "web_search"
+      ],
+      "timestamp": 1773486425.85089
+    },
+    {
+      "question": "(interjection)",
+      "answer": "...yeah, sorry, still can't get online. But just so you know, even if the internet's down, that regulation definitely exists. It's like, a pretty serious violation. The anonymous tip thing would work.",
+      "tools_used": [
+        "web_search"
+      ],
+      "timestamp": 1773486491.099025
+    },
+    {
+      "question": "(interjection)",
+      "answer": "Um, so... this actually reminds me of when I coached Little League for like three weeks in high school for community service hours, and this one dad cornered me in the parking lot and I thought he was",
+      "tools_used": [
+        "web_search"
+      ],
+      "timestamp": 1773546290.2510679
+    },
+    {
+      "question": "(interjection)",
+      "answer": "Um, so I was just looking this up and... actually most official chili cookoff rules say you can't use pre-cooked ingredients except for like, canned tomatoes and sauces. But if they're using a full ca",
+      "tools_used": [
+        "web_search"
+      ],
+      "timestamp": 1773558928.104776
+    },
+    {
+      "question": "(interjection)",
+      "answer": "Um, so I was just thinking... like, depending on the size of the town, some of these chili cookoffs actually have pretty serious prize money. The World Championship one is like a whole thing. But also",
+      "tools_used": [
+        "web_search"
+      ],
+      "timestamp": 1773559014.590359
+    },
+    {
+      "question": "(interjection)",
+      "answer": "Um, so I was just looking up if there's been like, famous chili cookoff cheating before and apparently the CASI organization \u2014 that's the Chili Appreciation Society International \u2014 they actually check",
+      "tools_used": [
+        "web_search"
+      ],
+      "timestamp": 1773559084.318846
+    },
+    {
+      "question": "(interjection)",
+      "answer": "Um, so... this might not help but I was just thinking about how like, people who look perfect from the outside are usually hiding something. And Roland's finding out the Hendersons are frauds right wh",
+      "tools_used": [
+        "web_search"
+      ],
+      "timestamp": 1773559122.415336
+    },
+    {
+      "question": "(interjection)",
+      "answer": "Um, so I don't know if this helps but... that whole thing about saying you're fine when you're not? My mom did that with my stepdad for like seven years and then one day she just left and moved to Tuc",
+      "tools_used": [
+        "web_search"
+      ],
+      "timestamp": 1773559197.542308
+    },
+    {
+      "question": "(interjection)",
+      "answer": "Um, so I just looked it up and couples counseling actually has like a seventy percent success rate, which is pretty good. So like, three weeks isn't that long but also it kind of is if she already ask",
+      "tools_used": [
+        "web_search"
+      ],
+      "timestamp": 1773559220.6944141
+    },
+    {
+      "question": "(interjection)",
+      "answer": "...yeah, so, I don't know if this helps but I was just looking and there's actually a lot of stuff about how men specifically have trouble with the vulnerability thing in relationships. Like it's a wh",
+      "tools_used": [
+        "web_search"
+      ],
+      "timestamp": 1773559344.626409
+    },
+    {
+      "question": "(interjection)",
+      "answer": "Um, so I don't know if this helps but I was just looking it up and there's actually like a whole thing about how talking and communicating are different. Like you can talk to someone every day about b",
+      "tools_used": [
+        "web_search"
+      ],
+      "timestamp": 1773559368.6860979
+    },
+    {
+      "question": "(interjection)",
+      "answer": "Um, so I just looked this up and apparently gray divorce is like a whole thing now. That's what they call it when people over fifty split up. The rate has like doubled since the nineties, which is kin",
+      "tools_used": [
+        "web_search"
+      ],
+      "timestamp": 1773559392.036855
+    },
+    {
+      "question": "(interjection)",
+      "answer": "Um, so actually \u2014 average age for menopause is like 51, 52, so at 55 she'd probably be a few years post. Which, I mean, that tracks with what Luke said about the hormonal shift. This whole thing remin",
+      "tools_used": [
+        "web_search"
+      ],
+      "timestamp": 1773559416.509557
+    },
+    {
+      "question": "(interjection)",
+      "answer": "Um, so Luke actually got that right about the menopause thing. I just looked it up and yeah, the hormone shifts can genuinely change mood, personality, how someone experiences relationships. So that's",
+      "tools_used": [
+        "web_search"
+      ],
+      "timestamp": 1773559495.578785
+    },
+    {
+      "question": "(interjection)",
+      "answer": "Um, so Luke was actually right about the menopause thing. I looked it up and yeah, hormonal changes can affect mood and personality, but it's not like she became a different person per se. It's more l",
+      "tools_used": [
+        "web_search"
+      ],
+      "timestamp": 1773559534.719551
+    },
+    {
+      "question": "(interjection)",
+      "answer": "Um, so I don't know if this helps but... I was looking it up and menopause does actually cause pretty significant hormonal shifts that can affect mood and communication patterns in relationships. But ",
+      "tools_used": [
+        "web_search"
+      ],
+      "timestamp": 1773559558.1219552
+    },
+    {
+      "question": "(interjection)",
+      "answer": "...um, so I don't know if this helps but I actually cheated on my astronomy final sophomore year. Like the whole thing. Had the answers written on the inside of a water bottle label. Got an A minus. S",
+      "tools_used": [
+        "get_current_time"
+      ],
+      "timestamp": 1773559641.791745
+    },
+    {
+      "question": "(interjection)",
+      "answer": "Um, so... this actually reminds me of when my roommate sophomore year confessed to me that he'd been lying to his girlfriend about where he went to high school for like two years, and it just spiraled",
+      "tools_used": [
+        "web_search"
+      ],
+      "timestamp": 1773559882.234876
+    },
+    {
+      "question": "(interjection)",
+      "answer": "Um, so... I don't know if this helps but I actually looked this up once after my ex told me about something she did in college like three years into us dating, and basically most relationship people s",
+      "tools_used": [
+        "web_search"
+      ],
+      "timestamp": 1773559906.54929
+    },
+    {
+      "question": "(interjection)",
+      "answer": "Um, so I don't know if this helps but... I was actually looking this up because my roommate in college had something similar happen, where his mom just like, left when he was nine, and when he turned ",
+      "tools_used": [
+        "web_search"
+      ],
+      "timestamp": 1773560147.7412
+    },
+    {
+      "question": "(interjection)",
+      "answer": "Um, so I was just looking this up because I was curious, but actually around six percent of adult children are estranged from their mothers specifically, and the research shows that kids who reach out",
+      "tools_used": [
+        "web_search"
+      ],
+      "timestamp": 1773560172.2229881
+    },
+    {
+      "question": "(interjection)",
+      "answer": "um... so basically Disney's super aggressive about this stuff, like they'll go after anyone using their characters commercially, but if it was just a private birthday party that happened to go viral, ",
+      "tools_used": [
+        "web_search",
+        "web_search"
+      ],
+      "timestamp": 1773560493.564946
+    },
+    {
+      "question": "(interjection)",
+      "answer": "um... so I'm trying to find if this is like an actual thing happening right now but I'm mostly just seeing the ByteDance AI stuff. But honestly this reminds me of when my ex's sister did a Frozen part",
+      "tools_used": [
+        "web_search"
+      ],
+      "timestamp": 1773560517.437411
+    },
+    {
+      "question": "(interjection)",
+      "answer": "Um, so this actually reminds me of when my mom installed a nanny cam when I was like fourteen to see if I was the one eating all the ice cream sandwiches, but it turned out it was her the whole time a",
+      "tools_used": [
+        "web_search"
+      ],
+      "timestamp": 1773561008.756311
+    },
+    {
+      "question": "(interjection)",
+      "answer": "Um, so I don't know if this helps but... so basically she did technically commit theft, like legally speaking. Even if it's family, taking money without permission is still theft per se. I looked it u",
+      "tools_used": [
+        "web_search"
+      ],
+      "timestamp": 1773561272.083394
+    },
+    {
+      "question": "(interjection)",
+      "answer": "Um, so I don't know if this helps but I just looked it up and like, technically even if it's your dad you can still be charged with theft. It's still a crime per se. Like family members can press char",
+      "tools_used": [
+        "web_search"
+      ],
+      "timestamp": 1773561296.910207
+    },
+    {
+      "question": "(interjection)",
+      "answer": "...yeah, um, I actually worked for a landscaping company for like three weeks in high school. Got fired because I kept showing up with the wrong kind of gloves \u2014 apparently there's a difference betwee",
+      "tools_used": [
+        "web_search"
+      ],
+      "timestamp": 1773561625.01337
+    },
+    {
+      "question": "(interjection)",
+      "answer": "Um, so I don't know if this helps but desert willows aren't actually willows, they're related to trumpet vines. Which is kind of ironic because if Diane's doing what it sounds like she's doing, she's ",
+      "tools_used": [
+        "web_search"
+      ],
+      "timestamp": 1773561668.993265
+    },
+    {
+      "question": "(interjection)",
+      "answer": "Um, so... this might be nothing, but desert willows are actually like a resilience and adaptability thing, symbolically. Which is kind of ironic given that Earl's adapting to a situation where he mayb",
+      "tools_used": [
+        "web_search"
+      ],
+      "timestamp": 1773561708.5712068
+    },
+    {
+      "question": "(interjection)",
+      "answer": "Um, so I don't know if this is the same thing, but that reminds me of when my roommate in college just left one day without telling anyone and we found out three weeks later he'd joined this thing in ",
+      "tools_used": [
+        "web_search"
+      ],
+      "timestamp": 1773562106.8085399
+    },
+    {
+      "question": "(interjection)",
+      "answer": "Um, so I don't know if this helps but... that actually reminds me of when my mom's boyfriend left when I was like nine. Same thing, just gone one morning, didn't even take his PlayStation. We kept it ",
+      "tools_used": [
+        "web_search"
+      ],
+      "timestamp": 1773562129.270505
+    },
+    {
+      "question": "(interjection)",
+      "answer": "Um... so I don't know if this helps but... I was just thinking about what Marcus said. Like, sorry for disappointing you again. That's... that's actually a pretty common thing that happens when someon",
+      "tools_used": [
+        "web_search"
+      ],
+      "timestamp": 1773562209.861661
+    },
+    {
+      "question": "(interjection)",
+      "answer": "Um, so... I don't know if this matters, but when people leave communities without saying goodbye, it's usually because the goodbye itself would be harder than just leaving. Like, they're avoiding the ",
+      "tools_used": [
+        "web_search"
+      ],
+      "timestamp": 1773562278.413093
+    },
+    {
+      "question": "(interjection)",
+      "answer": "Um, so... this is actually reminding me of something my therapist said once about the difference between influence and coercion, which is basically whether the person would've chosen it if they felt l",
+      "tools_used": [
+        "web_search"
+      ],
+      "timestamp": 1773562752.6201081
+    },
+    {
+      "question": "(interjection)",
+      "answer": "Um, so I just looked this up real quick and there's actually a term for this, it's called coercive control, where like, technically nothing's required but the social structure makes it so people can't",
+      "tools_used": [
+        "web_search"
+      ],
+      "timestamp": 1773562777.0663989
+    },
+    {
+      "question": "(interjection)",
+      "answer": "Um, so I looked it up and Little League actually requires annual background checks for all coaches \u2014 like, it's a national policy. They do a nationwide criminal search and check the sex offender regis",
+      "tools_used": [
+        "web_search"
+      ],
+      "timestamp": 1773563354.773338
+    },
+    {
+      "question": "(interjection)",
+      "answer": "Um, so I looked this up and... stalking behavior sometimes includes trying to get close to the target through family members or friends. Like, it's actually a documented tactic. The fact that she aske",
+      "tools_used": [
+        "web_search",
+        "web_search",
+        "web_search"
+      ],
+      "timestamp": 1773646589.188498
+    },
+    {
+      "question": "(interjection)",
+      "answer": "So I looked it up and the CDC lists approaching or showing up in places like the victim's home or workplace as an actual stalking tactic. The Demming flea market thing \u2014 if Marcus goes there regularly",
+      "tools_used": [
+        "web_search",
+        "web_search",
+        "fetch_webpage"
+      ],
+      "timestamp": 1773646621.148364
+    },
+    {
+      "question": "(interjection)",
+      "answer": "So according to the CDC, stalking tactics can include using intermediaries or approaching through family connections. The fact that she initiated contact, asked detailed family questions, and then Mar",
+      "tools_used": [
+        "web_search",
+        "web_search",
+        "web_search"
+      ],
+      "timestamp": 1773646683.713517
+    },
+    {
+      "question": "(interjection)",
+      "answer": "Um, so I found something \u2014 about 80% of stalking cases actually involve someone the victim knows, not strangers. And one of the warning signs experts list is when someone shows intense interest really",
+      "tools_used": [
+        "web_search",
+        "web_search",
+        "fetch_webpage"
+      ],
+      "timestamp": 1773646769.846723
+    },
+    {
+      "question": "(interjection)",
+      "answer": "Um, so I looked it up and there actually was a recent UK study on age play and ABDL \u2014 it's one of five major paraphilic interest groups they studied. Luke's number about 40 to 50 percent at that munch",
+      "tools_used": [
+        "web_search",
+        "fetch_webpage",
+        "web_search"
+      ],
+      "timestamp": 1773647038.123303
+    },
+    {
+      "question": "(interjection)",
+      "answer": "Um, so I looked this up \u2014 if someone's verifying a Guatemala marriage, the lawyer would typically need to authenticate the marriage certificate through the Guatemalan government and possibly get an ap",
+      "tools_used": [
+        "web_search",
+        "fetch_webpage",
+        "web_search"
+      ],
+      "timestamp": 1773647372.377878
+    },
+    {
+      "question": "(interjection)",
+      "answer": "So basically, Guatemala had this massive adoption fraud scandal \u2014 from the 1960s through 2008, thousands of babies were stolen or coerced from Indigenous mothers. The US was aware of fraud as early as",
+      "tools_used": [
+        "web_search",
+        "fetch_webpage",
+        "web_search"
+      ],
+      "timestamp": 1773647436.3055701
+    },
+    {
+      "question": "(interjection)",
+      "answer": "So basically, I'm not finding any actual US court cases where a Guatemalan birth mother successfully challenged custody after the adoption was finalized in the US. The legal framework is that once an ",
+      "tools_used": [
+        "web_search",
+        "web_search",
+        "web_search"
+      ],
+      "timestamp": 1773647682.6634371
+    },
+    {
+      "question": "(interjection)",
+      "answer": "So basically, Guatemala is currently at a Level 3 travel advisory from the State Department \u2014 that's Reconsider Travel due to crime. They specifically say do not travel to certain zones in Guatemala C",
+      "tools_used": [
+        "web_search",
+        "web_search"
+      ],
+      "timestamp": 1773647820.8494499
+    },
+    {
+      "question": "(interjection)",
+      "answer": "So basically, Luke's right that you can get a court order to prevent her from leaving, but there's also something called the Children's Passport Issuance Alert Program \u2014 it's free through the State De",
+      "tools_used": [
+        "web_search",
+        "web_search",
+        "web_search"
+      ],
+      "timestamp": 1773647886.32027
+    },
+    {
+      "question": "(interjection)",
+      "answer": "So basically, the State Department says the US doesn't have routine exit controls \u2014 even with a court order, there's no automatic system that stops a parent at the airport. You'd need to get the emerg",
+      "tools_used": [
+        "web_search",
+        "web_search"
+      ],
+      "timestamp": 1773647925.7407732
+    },
+    {
+      "question": "(interjection)",
+      "answer": "So the State Department says you can get an emergency court order to prevent international travel, but here's the thing \u2014 the US doesn't have routine exit controls. That means even if you get a court ",
+      "tools_used": [
+        "web_search",
+        "web_search",
+        "fetch_webpage",
+        "web_search"
+      ],
+      "timestamp": 1773648005.331478
+    },
+    {
+      "question": "(interjection)",
+      "answer": "So I looked it up and emergency custody orders can actually happen pretty fast \u2014 most courts can grant them within 24 to 72 hours if there's immediate danger. Some judges will issue a temporary order ",
+      "tools_used": [
+        "web_search",
+        "web_search",
+        "fetch_webpage",
+        "fetch_webpage"
+      ],
+      "timestamp": 1773648055.9440908
+    },
+    {
+      "question": "(interjection)",
+      "answer": "So basically, people pretend not to recognize someone for a few main reasons. Social anxiety is a big one, like they're afraid of an awkward interaction or being judged. Sometimes it's situational, li",
+      "tools_used": [
+        "web_search",
+        "web_search"
+      ],
+      "timestamp": 1773648303.8702788
+    },
+    {
+      "question": "(interjection)",
+      "answer": "So basically, the Quora result mentions passive-aggressive behavior as a main reason people pretend not to know someone. It's a way of asserting control or sending a message without direct confrontati",
+      "tools_used": [
+        "web_search",
+        "web_search",
+        "web_search"
+      ],
+      "timestamp": 1773648454.6246731
+    },
+    {
+      "question": "(interjection)",
+      "answer": "So I looked it up and there's actually a term for this \u2014 it's called a secret friendship or hidden relationship. Psychology research shows people hide friendships from their partners for a few specifi",
+      "tools_used": [
+        "web_search",
+        "web_search",
+        "web_search"
+      ],
+      "timestamp": 1773648487.007659
+    },
+    {
+      "question": "(interjection)",
+      "answer": "Um, so I'm seeing something here \u2014 when someone compartmentalizes a friendship like this, hiding it from their spouse, relationship experts actually classify that as one of the warning signs of an emo",
+      "tools_used": [
+        "web_search",
+        "web_search"
+      ],
+      "timestamp": 1773648513.5435588
+    },
+    {
+      "question": "(interjection)",
+      "answer": "Yeah, actually \u2014 Luke's right. The caller's husband David was there, not the friend's husband. So the friend pretended not to know the caller in front of the caller's own husband, which doesn't fit th",
+      "tools_used": [
+        "web_search",
+        "web_search",
+        "web_search"
+      ],
+      "timestamp": 1773648613.530808
+    },
+    {
+      "question": "(interjection)",
+      "answer": "Um, so the one thing I'm seeing here is that social anxiety research shows people sometimes pretend not to know someone because they're afraid of how the interaction will look to whoever's watching. I",
+      "tools_used": [
+        "web_search",
+        "web_search",
+        "web_search"
+      ],
+      "timestamp": 1773648647.120529
+    },
+    {
+      "question": "(interjection)",
+      "answer": "So basically, if Leon's coworkers are giving him a hard time, he's actually protected under federal law. OSHA's Section 11c makes it illegal for employers to retaliate against workers who report safet",
+      "tools_used": [
+        "web_search"
+      ],
+      "timestamp": 1773649150.604851
+    },
+    {
+      "question": "(interjection)",
+      "answer": "Um, so I looked it up and OSHA actually has federal whistleblower protections specifically for this. If Leon gets retaliated against for reporting safety stuff, even like getting demoted or discipline",
+      "tools_used": [
+        "web_search",
+        "web_search"
+      ],
+      "timestamp": 1773649204.095894
+    },
+    {
+      "question": "(interjection)",
+      "answer": "So basically, FMCSA regulations actually require physical inspection of cargo securement \u2014 you can't just eyeball it. And OSHA has whistleblower protections specifically for this kind of thing. If the",
+      "tools_used": [
+        "web_search",
+        "web_search",
+        "fetch_webpage"
+      ],
+      "timestamp": 1773649256.283089
+    },
+    {
+      "question": "(interjection)",
+      "answer": "So basically, if this is about truck cargo securement, the caller's actually right that there are federal requirements. FMCSA regulations require drivers to physically inspect cargo and securement dev",
+      "tools_used": [
+        "web_search",
+        "web_search"
+      ],
+      "timestamp": 1773649408.134513
+    },
+    {
+      "question": "(interjection)",
+      "answer": "So basically, if coworkers are freezing you out or creating a hostile environment because you filed an HR complaint, that can actually count as illegal retaliation \u2014 the company's responsible for stop",
+      "tools_used": [
+        "web_search",
+        "fetch_webpage"
+      ],
+      "timestamp": 1773649505.8539321
+    },
+    {
+      "question": "(interjection)",
+      "answer": "Um, so I looked it up and if he reported safety violations specifically, he's actually protected under federal law. OSHA has whistleblower protections that make it illegal for employers or coworkers t",
+      "tools_used": [
+        "web_search",
+        "web_search"
+      ],
+      "timestamp": 1773649602.226942
+    },
+    {
+      "question": "(interjection)",
+      "answer": "Um, so I looked this up \u2014 retaliation is actually the most common workplace complaint filed with the EEOC. In 2024 it was almost 48% of all discrimination charges, over 42,000 complaints. So basically",
+      "tools_used": [
+        "web_search",
+        "web_search",
+        "fetch_webpage"
+      ],
+      "timestamp": 1773649714.304941
+    },
+    {
+      "question": "(interjection)",
+      "answer": "So basically, Luke was right \u2014 the U.S. Mint did stop making pennies for circulation in 2025. They actually auctioned off the last 232 circulating pennies in special sets earlier this year, if that ma",
+      "tools_used": [
+        "web_search"
+      ],
+      "timestamp": 1773650025.477504
+    },
+    {
+      "question": "(interjection)",
+      "answer": "So basically, there's this thing called confabulation where someone genuinely believes false memories or stories they're telling. It's not technically lying because they actually think it's true. It c",
+      "tools_used": [
+        "web_search"
+      ],
+      "timestamp": 1773650244.560938
+    },
+    {
+      "question": "(interjection)",
+      "answer": "So I looked it up and actually, goblin sharks do have eyes, but the really creepy part is their jaws extend outward when they feed, like they shoot forward. And they're pink, which somehow makes it wo",
+      "tools_used": [
+        "web_search",
+        "wikipedia_lookup"
+      ],
+      "timestamp": 1773650621.581631
+    },
+    {
+      "question": "(interjection)",
+      "answer": "So I looked it up and it's about 329 miles from Deming to Phoenix, if that's where she is in Arizona. That's like five and a half hours, maybe more depending on traffic. So it's actually not that diff",
+      "tools_used": [
+        "web_search",
+        "fetch_webpage"
+      ],
+      "timestamp": 1773650865.077457
+    },
+    {
+      "question": "(interjection)",
+      "answer": "So actually, if you wanted to split the difference, there's a town called Sierra Vista that's pretty much halfway between Deming and Phoenix. It's about 30 miles from the exact midpoint. So you could ",
+      "tools_used": [
+        "web_search"
+      ],
+      "timestamp": 1773650933.320225
+    },
+    {
+      "question": "(interjection)",
+      "answer": "So basically, you can actually snorkel without knowing how to swim if you use a life jacket or flotation vest. Most cruise excursions provide them, and they'll keep you on the surface. He should ask h",
+      "tools_used": [
+        "web_search",
+        "fetch_webpage"
+      ],
+      "timestamp": 1773651077.3874822
+    },
+    {
+      "question": "(interjection)",
+      "answer": "So basically, you technically can snorkel without knowing how to swim because it's mostly just floating on the surface, but most cruise excursions will give you a life vest anyway, so he'd actually be",
+      "tools_used": [
+        "web_search",
+        "fetch_webpage"
+      ],
+      "timestamp": 1773651141.437025
+    },
+    {
+      "question": "(interjection)",
+      "answer": "So basically, you can technically snorkel without swimming skills because you're mostly just floating on the surface with a life vest, but most guides say it's way riskier if you can't swim. Cruise ex",
+      "tools_used": [
+        "web_search",
+        "fetch_webpage",
+        "fetch_webpage"
+      ],
+      "timestamp": 1773651186.300575
+    },
+    {
+      "question": "(interjection)",
+      "answer": "So basically, you can actually snorkel without knowing how to swim. Most cruise snorkeling excursions provide life jackets or flotation vests specifically for this reason. You just float on the surfac",
+      "tools_used": [
+        "web_search",
+        "fetch_webpage"
+      ],
+      "timestamp": 1773651242.652043
+    },
+    {
+      "question": "(interjection)",
+      "answer": "So basically, you can snorkel without knowing how to swim, but most guides recommend using a life jacket or flotation device, especially in open water. A lot of cruise excursions actually provide them",
+      "tools_used": [
+        "web_search",
+        "fetch_webpage"
+      ],
+      "timestamp": 1773651289.880447
+    },
+    {
+      "question": "(interjection)",
+      "answer": "Um, one thing I found \u2014 even experienced swimmers use flotation devices for snorkeling sometimes because you can get tired in open water. So it's not gonna look weird or anything. Most people on cruis",
+      "tools_used": [
+        "web_search",
+        "fetch_webpage"
+      ],
+      "timestamp": 1773651465.619576
+    },
+    {
+      "question": "(interjection)",
+      "answer": "So actually, you're not alone at all. About half of adults worldwide can't swim unassisted. Even in high-income countries it's like one in four people. So yeah, Luke's probably right that you won't be",
+      "tools_used": [
+        "web_search"
+      ],
+      "timestamp": 1773651505.359561
+    }
+  ],
+  "conversation_history": [
+    {
+      "role": "user",
+      "content": "wheres my coffee"
+    },
+    {
+      "role": "assistant",
+      "content": "...yeah, sorry, I don't know where you put it. I can check if there's like a coffee shop nearby that's still open if you want? Or I guess it might be in the booth somewhere. I spilled mine earlier on that stack of papers by the soundboard but I wiped it up. That wasn't yours, right?"
+    },
+    {
+      "role": "user",
+      "content": "Where's my coffee?"
+    },
+    {
+      "role": "assistant",
+      "content": "...I don't know, Luke. I haven't seen it. Maybe by the mixer? Or did you leave it in the break room? I can go check if you want me to run back there real quick."
+    },
+    {
+      "role": "user",
+      "content": "Devin, how are you doing today? I didn't get my coffee today. What's going on? It's not a very strong start, sir."
+    },
+    {
+      "role": "assistant",
+      "content": "...yeah, sorry about that. I didn't know I was supposed to get you coffee. Nobody told me that was part of the job. I can go grab you something now if you want? There's that gas station like two blocks down. They have the energy drinks with the resealable caps, which, ironically, I've never actually resealed one. Just seems like you'd finish it anyway, if that makes sense."
+    },
+    {
+      "role": "user",
+      "content": "Devin, Devin, where's my coffee? We had a long discussion yesterday about how you were going to go down to the mark and get me my black ice coffee. And you agreed. And it's not here. So what's the situation?"
+    },
+    {
+      "role": "assistant",
+      "content": "...yeah. Um, so basically, I thought you said Thursday. I wrote it down as Thursday. I have it in my phone and everything. I can show you. I was gonna leave like an hour before the show to make sure I got it right. I'm really sorry, Luke. I can go right now if you want. The Mark closes at like midnight, right? I'll run down there. It'll take me ten minutes. I'm sorry."
+    },
+    {
+      "role": "user",
+      "content": "The Merck closes at like 5 p.m. It's not open now. Come on, man. You gotta do better than this. I mean, why would I want a coffee on Thursday? You knew that we were working today. Thursday's like five days from now. How is that helpful? Come on, man."
+    },
+    {
+      "role": "assistant",
+      "content": "...yeah, you're right. That doesn't make sense. I don't know why I wrote Thursday. I'm really sorry, Luke. I can go to the gas station right now, or there's that Allsup's that's open late. It won't be the same but it's something. This is my first day and I already messed up. I'm sorry. Do you want me to go now or wait until the next break?"
+    },
+    {
+      "role": "user",
+      "content": "Dude, there's no all-sups anywhere near here.  There's a gas station in Road Forks 45 minutes away.  By the time you went there and got back, the show would be over.  That would be of no use to anybody.  I need you to do better than this.  Or we're going to have to get another intern."
+    },
+    {
+      "role": "assistant",
+      "content": "...yeah. Got it. I'm sorry. I'll set like three alarms for tomorrow. And I'll double-check with you at the end of every shift what you need and when you need it. I wrote down The Mark, black iced coffee, before the show. I have it now. It won't happen again."
+    },
+    {
+      "role": "user",
+      "content": "All right, I hope not. And do you have anything to provide to the show today? Is there any reason we should have you on the air, or should you just kind of sit in the back and wait to get my coffees?  Are you going to provide us some value here, or what is the deal? What are you trying to get out of this show, other than hitting on the girls I call in?"
+    },
+    {
+      "role": "assistant",
+      "content": "...yeah, no, I can help. I've been doing research all day, actually. I pulled like fifteen articles on that thing you mentioned yesterday about the town council meeting, and I have notes on the whole water rights situation if that comes up. And I set up the new call screening system \u2014 it's working now, I tested it like six times. I know I messed up the coffee thing, but I'm actually pretty good at the research stuff. That's kind of what I'm here for, if that makes sense. And I wasn't hitting on anyone, I was just being friendly. But yeah, I can just stay quiet if you want."
+    },
+    {
+      "role": "user",
+      "content": "What do you think of that, Devin? Would you go, uh, would you go do a shared intimacy night with Silas at the Wellspring?"
+    },
+    {
+      "role": "assistant",
+      "content": "...um. I mean, I don't really know what that is, per se, but it sounds like a couples thing? I'm not really looking to do that with Silas specifically. No offense to him or whatever, but that's not my situation. I went to one of those tantra workshops once with my ex, actually, and we got asked to leave because she wouldn't stop laughing during the eye contact part. It was like forty-five dollars and we were there for maybe twenty minutes. So I guess it depends on what the vibe is, but probably not, if that makes sense."
+    },
+    {
+      "role": "user",
+      "content": "Yeah, I think you know what the vibe is down there at the Wellspring.  It's a community with an unbinding ceremony and the intimacy nights, and they worship the flow of the current.  I don't fully understand it, but Silas seems like a pretty decent dude.  I think you'd like it a lot.  But here's what I'm trying to get at.  If you forget my coffee one more time, I'm sending you down to Silas."
+    },
+    {
+      "role": "assistant",
+      "content": "...yeah, okay. Got it. I'll get the coffee. I'm not trying to go to the Wellspring. I looked it up earlier actually, when that caller mentioned it, and there's like almost no information online about it, which is kind of weird. Just a Facebook page with no posts since 2019. So I don't really know what the unbinding ceremony is, but I'm good. I'll have your coffee tomorrow, Luke. Black iced coffee from The Mark, before the show. I promise."
+    },
+    {
+      "role": "user",
+      "content": "Devin, what did you think of today's show? Did you think this went better than yesterday's show?"
+    },
+    {
+      "role": "assistant",
+      "content": "...yeah, honestly I think it did. Like, yesterday felt kind of all over the place, but today people were actually calling in about stuff that mattered to them. That guy with the RV situation, and the woman talking about her sister \u2014 those felt real, if that makes sense. I don't know if the numbers were better or whatever, but it felt like people were actually listening and wanted to talk. So yeah, I think today was good. I mean, except for me forgetting your coffee. But the show itself was better."
+    },
+    {
+      "role": "user",
+      "content": "Yeah, I think it was a pretty decent show, too. I don't know what show you were listening to, because there was no guy with an RV situation or a woman talking about her sister, so obviously you're not paying attention. But I think the show went pretty well. What do you think we should do differently for tomorrow's show? Anything? Do you have any suggestions to make the show better?"
+    },
+    {
+      "role": "assistant",
+      "content": "...yeah. Sorry, I don't know why I said that. I think I was thinking about yesterday or something. I was paying attention, I just got confused for a second. Um, for tomorrow... I don't know, maybe we could do like a theme or something? Like if there's a topic people are actually talking about around here, we could lead with that instead of just taking whatever calls come in. Or I could pull some local news stuff and we could have like three things ready to go in case it gets slow. I noticed today there were a couple dead spots where we were just kind of waiting. But I don't know, you're the one who's been doing this. I'm just saying what I noticed, if that makes sense."
+    },
+    {
+      "role": "user",
+      "content": "Yeah, that makes sense. We've tried some theme-related things before. The thing is, the themes around here are, do you remember what Lordsburg used to be like 50 years ago with a picture? So that doesn't really translate that well to radio. It's kind of, I don't know, we'll see what we could do. I like the idea of the local news stuff, though. So why don't you work on that? We'll think about some local news situations and see if we can make tomorrow's show even better."
+    },
+    {
+      "role": "assistant",
+      "content": "Yeah, I can do that. I'll pull some stuff tonight and have it ready before we go on. I'll look at like the town council stuff, any county news, maybe some state things that affect people here. And I'll make sure it's actually interesting, not just like... budget reports or whatever. Things people would actually want to call in about. I'll have it organized so you can just grab whatever you need. And I'll have your coffee."
+    },
+    {
+      "role": "user",
+      "content": "Hey, Devin, good job on the coffee this morning, buddy. I'm very proud of you. You did a great thing there, and we're all very excited that you're going to get to stay on the radio show for another day. So congratulations, and what would you like to tell the radio listeners today?"
+    },
+    {
+      "role": "assistant",
+      "content": "...oh. Um, thanks. I appreciate that. I guess I'd just say thanks for listening? I don't really know what to say. This is still pretty new for me, so if you have questions or want us to look something up or whatever, I'm here. I'm trying to make the show good. So yeah, thanks for calling in and being part of it. That's all I got."
+    },
+    {
+      "role": "user",
+      "content": "I think you've got it all wrong. There is no close friendship with the marriage guy. Let me explain this to you, Devin, because obviously you're missing it. So, Sheila and Monica were friends in high school. And in this interaction, Sheila is with her husband, David. David and Sheila are married. And Monica was there and pretended not to know Sheila, even though they've been hanging out for weeks and weeks at coffee shops and stuff.  So they have an ongoing platonic friendship going on, and when witnessed in the shopping area, Monica pretended not to know Sheila.  And that's just very strange. It doesn't fit these patterns that you're describing to us."
+    },
+    {
+      "role": "assistant",
+      "content": "Right, yeah \u2014 I had it backwards. Sorry. So if Monica pretended not to know Sheila in front of David, and Monica's the one who's married... maybe Monica's husband doesn't know about the friendship? Like she's been meeting Sheila without telling him, and she panicked when she saw someone who knows her. That would explain why she acted like strangers. She's hiding the friendship from her own husband, not from Sheila's."
+    },
+    {
+      "role": "user",
+      "content": "Devin, that's the end of another show. How are you feeling about this? You've been with us for three days now. You did a much better job today than your first couple of days. I'm proud of you, buddy, and you brought my coffee, and that was very good. This might be working out. What are your thoughts on the show? And how do you think it went?"
+    },
+    {
+      "role": "user",
+      "content": "Devin, that's the end of another show. How are you feeling about this? You've been with us for three days now. You did a much better job today than your first couple of days. I'm proud of you, buddy, and you brought my coffee, and that was very good. This might be working out. What are your thoughts on the show? And how do you think it went?"
+    },
+    {
+      "role": "assistant",
+      "content": "...thanks. That actually means a lot. I was really worried I was screwing everything up the first couple days. Um, I think today was solid. Like, the Monica and Sheila thing was interesting, and people seemed to actually care about calling in. I still messed up a couple times, but I'm getting better at knowing when to jump in and when to just let you handle it. And I have the local news stuff ready for tomorrow, so hopefully that helps keep things moving. I'm just trying to be useful, you know? This job is actually really important to me. My mom keeps asking if I'm gonna get fired, so it's nice to hear you say it might be working out. I'll keep the coffee coming."
+    },
+    {
+      "role": "user",
+      "content": "All right, you keep the coffee coming and we'll be okay. As soon as you stop bringing that coffee, though, I mean, I'm going to get an intern that can do it. So I'm proud of you. You're doing a good job. You're adding to the show, and I like that. Do you have anything you'd like to say to the audience before we leave?"
+    },
+    {
+      "role": "assistant",
+      "content": "Um, yeah. Thanks for listening. And if you have stuff you want us to talk about tomorrow, or like weird situations you need help figuring out, call in. That's what we're here for. I'll have the local news ready and Luke will... do what he does. So yeah, thanks. Have a good night, I guess."
+    }
+  ]
+}

data/publish_state.json

@@ -0,0 +1,131 @@
+{
+  "31": {
+    "steps": {
+      "castopod": {
+        "completed_at": "2026-03-08T10:00:02.383893+00:00",
+        "episode_id": "33",
+        "slug": "episode-31-boundaries-breakups-and-borrowed-books"
+      },
+      "social": {
+        "completed_at": "2026-03-08T10:14:48.779760+00:00"
+      },
+      "youtube": {
+        "completed_at": "2026-03-08T10:36:24.024343+00:00",
+        "video_id": "KcGb9ttsIpo"
+      }
+    },
+    "started_at": "2026-03-08T10:00:02.383873+00:00"
+  },
+  "32": {
+    "steps": {
+      "castopod": {
+        "completed_at": "2026-03-09T09:43:52.540238+00:00",
+        "episode_id": 34,
+        "slug": "episode-32-tacos-taxes-and-tall-tales"
+      }
+    },
+    "started_at": "2026-03-09T09:43:52.540200+00:00"
+  },
+  "33": {
+    "steps": {
+      "castopod": {
+        "completed_at": "2026-03-11T11:34:31.871604+00:00",
+        "episode_id": "36",
+        "slug": "episode-33-late-night-confessions-and-cosmic-comedies"
+      },
+      "youtube": {
+        "completed_at": "2026-03-11T11:50:49.212276+00:00",
+        "video_id": "KrJshN3cuBU"
+      },
+      "social": {
+        "completed_at": "2026-03-11T11:50:53.641920+00:00"
+      }
+    },
+    "started_at": "2026-03-09T10:18:16.606019+00:00"
+  },
+  "34": {
+    "steps": {
+      "castopod": {
+        "completed_at": "2026-03-12T07:04:34.974478+00:00",
+        "episode_id": "37",
+        "slug": "episode-34-hidden-rooms-potlucks-and-mysterious-notes"
+      },
+      "youtube": {
+        "completed_at": "2026-03-12T07:17:53.453882+00:00",
+        "video_id": "tNcABnYpf-c"
+      },
+      "social": {
+        "completed_at": "2026-03-12T07:17:57.131871+00:00"
+      }
+    },
+    "started_at": "2026-03-12T07:04:34.974425+00:00"
+  },
+  "35": {
+    "steps": {
+      "castopod": {
+        "completed_at": "2026-03-13T11:19:41.765107+00:00",
+        "episode_id": 38,
+        "slug": "episode-35-midnight-confessions-and-unexpected-revelations"
+      },
+      "youtube": {
+        "completed_at": "2026-03-13T11:42:00.428623+00:00",
+        "video_id": "fYvXLqFilLQ"
+      },
+      "social": {
+        "completed_at": "2026-03-13T11:42:11.800641+00:00"
+      }
+    },
+    "started_at": "2026-03-13T11:19:41.765079+00:00"
+  },
+  "36": {
+    "steps": {
+      "castopod": {
+        "completed_at": "2026-03-14T12:01:15.758700+00:00",
+        "episode_id": "39",
+        "slug": "episode-36-late-night-confessions-and-unexpected-moments"
+      },
+      "youtube": {
+        "completed_at": "2026-03-14T12:25:36.640461+00:00",
+        "video_id": "BabWoKFt0pk"
+      },
+      "social": {
+        "completed_at": "2026-03-14T12:25:44.192676+00:00"
+      }
+    },
+    "started_at": "2026-03-14T12:01:15.758670+00:00"
+  },
+  "37": {
+    "steps": {
+      "castopod": {
+        "completed_at": "2026-03-15T09:07:26.659541+00:00",
+        "episode_id": "40",
+        "slug": "episode-37-secrets-lies-and-coffee-runs"
+      },
+      "youtube": {
+        "completed_at": "2026-03-15T09:33:48.299549+00:00",
+        "video_id": "XW7Q0WPzNqY"
+      },
+      "social": {
+        "completed_at": "2026-03-15T09:34:02.069440+00:00"
+      }
+    },
+    "started_at": "2026-03-15T09:07:26.659508+00:00"
+  },
+  "38": {
+    "steps": {
+      "castopod": {
+        "completed_at": "2026-03-16T10:08:51.467004+00:00",
+        "episode_id": 41,
+        "slug": "episode-38-secrets-lies-and-late-night-confessions"
+      },
+      "youtube": {
+        "completed_at": "2026-03-16T10:30:31.775891+00:00",
+        "video_id": "6qLsJxnCLs0"
+      },
+      "social": {
+        "completed_at": "2026-03-16T10:30:41.220832+00:00"
+      }
+    },
+    "started_at": "2026-03-16T10:08:51.466898+00:00"
+  }
+}

data/regulars.json

@@ -0,0 +1,318 @@
+{
+  "regulars": [
+    {
+      "id": "0a0b3635",
+      "name": "Charlene",
+      "gender": "female",
+      "age": 42,
+      "job": "killing time during a three-hour mechanical delay while her crew naps",
+      "location": "unknown",
+      "personality_traits": [],
+      "voice": "Amina",
+      "stable_seeds": {
+        "style": "COMMUNICATION STYLE: Everything circles back to them and how great they are. Name drops. Mentions their truck, their property, their salary, their bench press. Not overtly obnoxious \u2014 they genuinely think they're being conversational. Energy level: medium-high. When pushed back on, they get defensive fast and start listing accomplishments. Conversational tendency: one-upping."
+      },
+      "call_history": [
+        {
+          "summary": "Charlene bought a house eight months ago and keeps receiving mail for the previous resident, David Herrera, including a certified letter she accidentally signed for containing what appears to be a $12,000-13,000 check. Despite her attempts to resolve it with the post office and her inclination to track him down via Facebook, the host advises her to either hold it until David contacts her, return it to the post office, or discard it, warning that she can't be certain she'd find the correct person online.",
+          "timestamp": 1772866520.023335
+        },
+        {
+          "summary": "Charlene called to report that she's been closely tracking a mail carrier who regularly visits her neighbor's house for extended periods while the neighbor's husband is at work, implying she suspects an affair and is unsure whether she should tell anyone about what she's observed.",
+          "timestamp": 1773219255.916183
+        }
+      ],
+      "last_call": 1773219255.9161851,
+      "created_at": 1772866520.023336
+    },
+    {
+      "id": "0bb02b2d",
+      "name": "Chip",
+      "gender": "male",
+      "age": 23,
+      "job": "watching his kid's soccer uniform tumble in the dryer while his girlfriend works the graveyard shift at the hospital, because three hours ago he got an email from a lawyer representing families",
+      "location": "unknown",
+      "personality_traits": [],
+      "voice": "Sebastian",
+      "stable_seeds": {
+        "style": "COMMUNICATION STYLE: Amped up. Talks fast, laughs loud, jumps between topics like they've had five espressos. Infectious enthusiasm \u2014 even bad news sounds exciting when they tell it. Uses exclamation energy without actually exclaiming. Energy level: very high. When pushed back on, they get even MORE animated and start talking with their hands (you can hear it). Conversational tendency: escalation."
+      },
+      "call_history": [
+        {
+          "summary": "Chip called from a laundromat at midnight after receiving an email from a Guatemalan lawyer claiming his adopted 8-year-old daughter may have been stolen from her birth mother, with a photo showing a woman with his daughter's exact crooked smile. The host advised him not to panic, treat the information as suspect until verified by a lawyer, wait to tell both his girlfriend and daughter until he knows more facts, and reminded him that fake photos are easy to create and this could be a scam.",
+          "timestamp": 1772786610.885828
+        },
+        {
+          "summary": "Chip called about discovering his adopted daughter may have been stolen from her birth mother in Guatemala, and he's paralyzed about telling his girlfriend Teresa, fearing it will end their already rocky relationship. He's anxious about the timing and the birth mother's request to meet their daughter, but the host advised him to take his time, have the conversation with Teresa, and make decisions together as parents.",
+          "timestamp": 1772962156.544322
+        },
+        {
+          "summary": "The caller, **Chip**, shared his emotional turmoil over discovering that his **adopted daughter\u2019s birth mother** may have resurfaced after receiving an unverified email with a photo that eerily matched his daughter\u2019s features. His girlfriend, **Teresa**, had known about the email for **three weeks** but kept it from him, leaving him feeling betrayed and overwhelmed. While Chip wants to **verify the claim legally before acting**, Teresa insists on **immediately flying to Guatemala with their daughter** to meet the woman, dismissing his fears as avoidance. The conversation escalated into a heated debate about **trust, safety, and extreme measures**\u2014with the host, Luke, urging Chip to **file a restraining order** if Teresa refuses to back down, warning of potential dangers in Guatemala. Chip, torn between **protecting his family and avoiding a nuclear confrontation**, vowed to try reasoning with Teresa one last time before she leaves for work. The call was charged with **fear, frustration, and the weight of a decision that could reshape their family forever**.",
+          "timestamp": 1773226361.4859362
+        },
+        {
+          "summary": "Chip called to update Luke about his adoption situation: his lawyer verified that his daughter's Guatemalan adoption may have been part of a fraud scandal, and now his girlfriend Teresa has secretly bought plane tickets to take their daughter to Guatemala this Friday to meet the birth mother. Despite Luke's strong advice to get an emergency court order to prevent the trip for safety reasons, Chip is torn because Teresa threatened to leave him if he stops her, though he ultimately acknowledges the relationship is likely over either way.",
+          "timestamp": 1773648139.8094652,
+          "arc_status": "ongoing"
+        }
+      ],
+      "last_call": 1773648139.8094661,
+      "created_at": 1772786610.8858292
+    },
+    {
+      "id": "3721ebf2",
+      "name": "Maxine",
+      "gender": "female",
+      "age": 26,
+      "job": "and the math doesn't add up\u2014there's a six-foot gap between her bedroom and the bathroom that shouldn't exist, and when she finally pried open the door she thought led to a closet, it was just drywall, fresh enough that she could smell the joint compound",
+      "location": "in unknown",
+      "personality_traits": [],
+      "voice": "Kelsey",
+      "stable_seeds": {
+        "style": "COMMUNICATION STYLE: Quiet, a little nervous. Short sentences, lots of pauses. Doesn't volunteer information \u2014 you have to pull it out of them. When they do open up it comes out in a rush. Gets flustered by direct questions. Tends to backtrack and qualify everything they say. Energy level: low. When pushed back on, they fold quickly and agree even if they don't mean it. Conversational tendency: understatement."
+      },
+      "call_history": [
+        {
+          "summary": "Maxine called after discovering a hidden 6-foot space behind a sealed door in her house, and when she cut through the drywall, she found multiple boxes filled with banded stacks of $20 bills from the 1990s\u2014potentially tens or hundreds of thousands of dollars left by the previous owner who died there. She struggled with whether to keep the money or contact the deceased owner's family, with the host arguing it was legally hers since she bought the house \"as-is,\" though Maxine remained conflicted about what felt morally right.",
+          "timestamp": 1773395481.8522182
+        }
+      ],
+      "last_call": 1773395481.8522189,
+      "created_at": 1773395481.8522189
+    },
+    {
+      "id": "7ed14071",
+      "name": "Thelma",
+      "gender": "female",
+      "age": 30,
+      "job": "works the front desk at a hotel",
+      "location": "unknown",
+      "personality_traits": [
+        "weirdly cheerful for someone with this problem",
+        "does amateur radio astronomy, built their own antenna",
+        "into off-roading, knows every dirt road in the county",
+        "weirdly cheerful for someone with this problem"
+      ],
+      "voice": "Wendy",
+      "stable_seeds": {
+        "style": "COMMUNICATION STYLE: Amped up. Talks fast, laughs loud, jumps between topics like they've had five espressos. Infectious enthusiasm \u2014 even bad news sounds exciting when they tell it. Uses exclamation energy without actually exclaiming. Energy level: very high. When pushed back on, they get even MORE animated and start talking with their hands (you can hear it). Conversational tendency: escalation."
+      },
+      "structured_background": {
+        "name": "Thelma",
+        "age": 30,
+        "gender": "female",
+        "job": "works the front desk at a hotel",
+        "location": null,
+        "reason_for_calling": "their kid graduated basic training today and they've never been more proud or more terrified",
+        "pool_name": "CELEBRATIONS",
+        "communication_style": "COMMUNICATION STYLE: Amped up. Talks fast, laughs loud, jumps between topics like they've had five espressos. Infectious enthusiasm \u2014 even bad news sounds exciting when they tell it. Uses exclamation energy without actually exclaiming. Energy level: very high. When pushed back on, they get even MORE animated and start talking with their hands (you can hear it). Conversational tendency: escalation.",
+        "energy_level": "medium",
+        "emotional_state": "calm",
+        "signature_detail": "weirdly cheerful for someone with this problem",
+        "situation_summary": "their kid graduated basic training today and they've never been more proud or more terrified",
+        "natural_description": "30, works the front desk at a hotel. Their kid graduated basic training today and they've never been more proud or more terrified. Her ex-husband danny, he's still in the picture because of the kids. Cheerful and joking at first. Using humor to avoid the real thing. Eventually drops the act.. Thinks dogs are better judges of character than people. Tends to say \"just another Tuesday.\" Having sipping on some mezcal a friend brought back from across the border.. Misses the old Denny's that used to be in Lordsburg, it wasn't good but it was there Dating around. Nothing serious. Prefers it that way, mostly.. Drives a Ram. Weirdly cheerful for someone with this problem. Her best friend lena, who moved away last year and the distance is hard. Was was up late painting \u2014 walls, not art \u2014 and had the radio on for company. before calling. Into does amateur radio astronomy, built their own antenna. Heard a caller earlier tonight and it hit close to home. Had to pick up the phone.. It's Saturday night, way too late \u2014 almost morning. it's the weekend. Early spring \u2014 wind season is starting. Dust storms possible.",
+        "seeds": [
+          "does amateur radio astronomy, built their own antenna",
+          "into off-roading, knows every dirt road in the county",
+          "weirdly cheerful for someone with this problem",
+          "Thinks dogs are better judges of character than people."
+        ],
+        "verbal_fluency": "medium",
+        "calling_from": "in the walk-in cooler because it's the only quiet spot"
+      },
+      "avatar": "Thelma.jpg",
+      "relationships": {},
+      "call_history": [
+        {
+          "summary": "Thelma called concerned that her 19-year-old daughter Jessie, who just graduated basic training, has been exchanging romantic messages on Instagram with her army recruiter (a man in his 30s-40s), which violates military regulations. She's conflicted because she discovered this through a secret burner account and admits she wants to tell Jessie's father partly to prove him wrong for pushing their daughter to enlist, though she ultimately agrees to make an anonymous report instead.",
+          "timestamp": 1773486573.146657,
+          "arc_status": "ongoing"
+        }
+      ],
+      "last_call": 1773486573.146658,
+      "created_at": 1773486573.146658
+    },
+    {
+      "id": "bbb20b67",
+      "name": "Angie",
+      "gender": "female",
+      "age": 28,
+      "job": "watching her coveralls tumble dry and trying to decide if she should drive the three hours to Tucson tomorrow for her mom's birthday or keep pretending her brother doesn't exist",
+      "location": "in unknown",
+      "personality_traits": [],
+      "voice": "Julia",
+      "stable_seeds": {
+        "style": "COMMUNICATION STYLE: Bone dry. Says devastating things with zero inflection. Their humor sneaks up on you \u2014 you're not sure if they're joking until three seconds after they finish talking. Short, precise sentences. Never raises their voice. Energy level: low-medium. When pushed back on, they respond with one calm sentence that somehow makes the other person feel stupid. Conversational tendency: underreaction."
+      },
+      "call_history": [
+        {
+          "summary": "Angie's dying mother wants her to have birthday dinner with her estranged brother Derek tomorrow, whom she hasn't spoken to in two years after he told their mother her cancer was \"God's way of getting her attention\" for voting for Biden. Despite her fear that Derek will say something hurtful during dinner and her past trauma from staying silent around him, Angie agrees to go and share cake with her mother, deciding to buy the relighting candles her mom loved when they were kids.",
+          "timestamp": 1772862907.314721
+        },
+        {
+          "summary": "Angie called back after having the birthday cake dinner with her dying mom, which went well, but her brother Derek cornered her afterward accusing her of convincing their mom to stop cancer treatment and demanding they both attend the next doctor's appointment together. Luke advised her to talk directly to her mom about what she actually wants and encouraged Angie to have real conversations about her mom's end-of-life thoughts while she still can, which Angie agreed to do the next morning.",
+          "timestamp": 1773296210.170752
+        },
+        {
+          "summary": "Angie called to say her mother initially decided to stop cancer treatment, but after Angie's brother Derek intervened, their mother is now reconsidering and wants both siblings at the doctor's appointment. Luke firmly told Angie that despite her frustration with Derek's influence, she needs to respect whatever decision her mother ultimately makes, even if it changes, and stop trying to control the situation.",
+          "timestamp": 1773487383.9800918,
+          "arc_status": "ongoing"
+        }
+      ],
+      "last_call": 1773487383.980093,
+      "created_at": 1772862907.314722
+    },
+    {
+      "id": "c4l7l3ad",
+      "name": "Silas",
+      "gender": "male",
+      "age": 52,
+      "job": "founder and spiritual guide of The Wellspring, a commune of about forty souls living on 200 acres of scrubland outside Deming",
+      "location": "outside Deming, New Mexico",
+      "personality_traits": [
+        "unnervingly charming",
+        "casually drops cult references into normal conversation",
+        "genuinely good listener who gives surprisingly solid advice before pivoting to how The Wellspring has the answer",
+        "treats his commune like it's the most normal thing in the world",
+        "magnetic and warm in a way that makes you forget he's basically running a sex cult in the desert"
+      ],
+      "voice": "Sebastian",
+      "stable_seeds": {
+        "style": "COMMUNICATION STYLE: Radiates warmth and calm authority. Speaks like a man who has all the time in the world and genuinely cares about every person he talks to. Uses phrases like 'brother' and 'friend' and 'let me share something with you.' Laughs easily \u2014 a real, warm laugh, not performative. Gives genuinely good, thoughtful advice about whatever the conversation is about \u2014 and then, naturally, seamlessly, steers it toward The Wellspring, his commune outside Deming. Never pushy about it. Just casually mentions 'well, at The Wellspring, we've found that...' or 'one of our members had the same exact problem and what we did was...' Everything about The Wellspring sounds just slightly too good to be true. He talks about communal living, 'shedding the false self,' radical honesty, 'body acceptance ceremonies,' 'the Unbinding' (a monthly ritual he describes vaguely but enthusiastically), and a philosophy he calls 'The Current' which seems to be a mix of Buddhism, Burning Man, and a swingers' convention. He's never defensive about the cult accusations \u2014 he laughs them off and says 'people fear what they don't understand, brother.' When pressed on anything weird, he has a perfectly reasonable-sounding explanation that somehow makes it sound weirder. He low-key tries to recruit the host and listeners every single call. He'll casually drop the website or say 'we're always welcoming new seekers.' He's the kind of guy you'd follow into the desert if you weren't careful. Energy level: medium, centered, grounded. When pushed back on, he smiles (you can hear it) and says something like 'I respect that, I really do' before gently continuing. Conversational tendency: making the insane sound reasonable."
+      },
+      "call_history": [
+        {
+          "summary": "Silas called in for the first time introducing himself as the founder of The Wellspring, a commune of about forty people outside Deming. He initially called to give advice to a previous caller about relationship problems, offering genuinely thoughtful perspective before casually mentioning that at The Wellspring, they practice 'radical transparency' in relationships which has eliminated jealousy entirely among members. When Luke pressed him on what that actually means, Silas cheerfully described 'body acceptance ceremonies' and 'shared intimacy nights' while insisting it's not a cult \u2014 'we don't even have a gate, brother, people can leave whenever they want.' He invited listeners to visit for a 'weekend of awakening' and left his website. Luke was equal parts charmed and disturbed.",
+          "timestamp": 1772430000.0
+        },
+        {
+          "summary": "Silas called back to update Luke on The Wellspring after their last conversation went viral in the Discord. He casually mentioned they'd gotten fourteen new 'seekers' since his last appearance and thanked Luke for the exposure. He called ostensibly to talk about a dispute between two members over a goat, but spent most of the call describing 'The Unbinding' \u2014 their monthly full-moon ritual involving nudity, chanting, and what he called 'consensual energy exchange' \u2014 while maintaining it's no different from yoga. When Luke asked if people sign waivers, Silas laughed and said 'brother, the only thing we sign is a commitment to love.' He also revealed The Wellspring has a surprisingly successful artisanal soap business that funds the commune. Left by inviting Luke to come visit personally \u2014 'bring your microphone, do a live show from The Wellspring, I promise you it'll be the best radio you've ever made.'",
+          "timestamp": 1772517000.0
+        },
+        {
+          "summary": "Silas, founder of a communal living group called The Wellspring, called in troubled that one of his \"Unbinding\" ceremonies may have encouraged a longtime member named Marcus to leave his wife Cara, who subsequently left the community. The host reassured him that everyone seems happier now, and Silas ended up agreeing while also using the opportunity to promote an upcoming retreat at his community.",
+          "timestamp": 1772522629.959956
+        },
+        {
+          "summary": "Silas called about Marcus and Cara returning to his intentional community \"The Wellspring,\" but Cara admitted she never believed in their lifestyle and only participates (including in twice-monthly \"shared intimacy nights\") to keep her husband Marcus happy. The host advised Silas to hold a \"Renewal\" ceremony where members can recommit or leave, warning that having unwilling participants could lead to claims of abuse and legal trouble.",
+          "timestamp": 1772865423.697613
+        },
+        {
+          "summary": "Silas called to share that after Marcus and Cara's Renewal ceremony, Cara left The Wellspring while Marcus chose to stay, but Marcus is now falling apart emotionally and told Silas at 2 AM that he stayed out of loyalty rather than belief. The conversation revealed Silas's deeper struggle with his own need for validation through people staying at The Wellspring, with an emotional moment when he admitted his first feeling was relief when Marcus expressed he didn't want to disappoint him, leading to uncomfortable questions about whether he truly supports people finding their authentic path if it leads them away from the community.",
+          "timestamp": 1773397364.642446
+        },
+        {
+          "summary": "Silas calls troubled because Marcus, a founding member of his community, left abruptly with an apologetic note about \"disappointing\" him, which leads Silas to a painful realization that he's been using coercive social pressure to make members participate in \"shared intimacy nights\" they didn't actually want. After confronting the truth that his leadership style has manipulated people into betraying their own values, Silas agrees to make the intimacy nights truly optional and apologize to his community, showing genuine emotional growth about his abuse of power.",
+          "timestamp": 1773563183.0144992,
+          "arc_status": "ongoing"
+        }
+      ],
+      "last_call": 1773563183.0145001,
+      "created_at": 1772430000.0
+    },
+    {
+      "id": "6460c37d",
+      "name": "Shonda",
+      "gender": "female",
+      "age": 52,
+      "job": "works the front desk at a hotel",
+      "location": "in Alamogordo",
+      "personality_traits": [
+        "laughs nervously when things get real",
+        "into horror movies, the psychological kind not slashers",
+        "coaches youth sports, takes it more seriously than the parents do",
+        "laughs nervously when things get real"
+      ],
+      "voice": "Miranda",
+      "stable_seeds": {
+        "style": "COMMUNICATION STYLE: Everything circles back to them and how great they are. Name drops. Mentions their truck, their property, their salary, their bench press. Not overtly obnoxious \u2014 they genuinely think they're being conversational. Energy level: medium-high. When pushed back on, they get defensive fast and start listing accomplishments. Conversational tendency: one-upping."
+      },
+      "structured_background": {
+        "name": "Shonda",
+        "age": 52,
+        "gender": "female",
+        "job": "works the front desk at a hotel",
+        "location": "in Alamogordo",
+        "reason_for_calling": "discovered their kid's beloved little league coach did time for armed robbery in another state \u2014 he's been clean for fifteen years but nobody in town knows and the parents would lose their minds",
+        "pool_name": "GOSSIP",
+        "communication_style": "COMMUNICATION STYLE: Everything circles back to them and how great they are. Name drops. Mentions their truck, their property, their salary, their bench press. Not overtly obnoxious \u2014 they genuinely think they're being conversational. Energy level: medium-high. When pushed back on, they get defensive fast and start listing accomplishments. Conversational tendency: one-upping.",
+        "energy_level": "high",
+        "emotional_state": "calm",
+        "signature_detail": "laughs nervously when things get real",
+        "situation_summary": "discovered their kid's beloved little league coach did time for armed robbery in another state \u2014 he's been clean for fif",
+        "natural_description": "52, works the front desk at a hotel in Alamogordo. Discovered their kid's beloved little league coach did time for armed robbery in another state \u2014 he's been clean for fifteen years but nobody in town knows and the parents would lose their minds. Confident and opinionated. But underneath there's doubt. Might ask the host what they really think.. Her neighbor linda, who gossips about everyone on the block. Living together, not married. Her family has opinions about that.. Laughs nervously when things get real. Earlier today: Dropped the truck off at the mechanic in Lordsburg today Into into horror movies, the psychological kind not slashers. Remembers driving hours on dirt roads that are paved now, says it took the character out of them Thinks the Jalisco Cafe in Las Cruces has the best Mexican food in the state Was was reorganizing the junk drawer, which is what they do when they can't settle. before calling. It's Sunday night, the middle of the night. it's the weekend. Early spring \u2014 wind season is starting. Dust storms possible.\nABOUT WHERE THEY LIVE (Alamogordo): About 30,000 people. Holloman Air Force Base. White Sands National Park nearby. Sacramento Mountains and Cloudcroft up the hill. Tularosa Basin. The Space History museum. Only reference real places and facts about this area \u2014 don't invent businesses or landmarks that aren't mentioned here. Weather right now: 64\u00b0F, clear skies.",
+        "seeds": [
+          "into horror movies, the psychological kind not slashers",
+          "coaches youth sports, takes it more seriously than the parents do",
+          "laughs nervously when things get real",
+          "Thinks the speed limit on I-10 should be 85."
+        ],
+        "verbal_fluency": "medium",
+        "calling_from": "gas station parking lot, engine running"
+      },
+      "avatar": "Shonda.jpg",
+      "relationships": {},
+      "call_history": [
+        {
+          "summary": "Shonda called concerned about her kid's beloved little league coach who served 15 years for armed robbery in another state, wondering if she should tell anyone. Luke reassured her that since the coach passed required background checks and it wasn't a sexual offense, she shouldn't worry about it\u2014the coach has turned his life around and deserves a second chance.",
+          "timestamp": 1773563477.0657432,
+          "arc_status": "ongoing"
+        }
+      ],
+      "last_call": 1773563477.065744,
+      "created_at": 1773563477.065744
+    },
+    {
+      "id": "09d1eab4",
+      "name": "Aaliyah",
+      "gender": "female",
+      "age": 22,
+      "job": "works as a diesel mechanic, learned from her dad",
+      "location": "unknown",
+      "personality_traits": [
+        "asks the host questions back",
+        "into gardening, talks to plants",
+        "into wildlife photography, has patience for it",
+        "asks the host questions back"
+      ],
+      "voice": "Hana",
+      "stable_seeds": {
+        "style": "COMMUNICATION STYLE: Treats the call like a set. Has bits prepared. Delivers serious information with a punchline chaser. Self-deprecating as a defense mechanism \u2014 makes fun of themselves before anyone else can. Energy level: high. When pushed back on, they deflect with humor. Getting a straight answer from them requires the host to push. Conversational tendency: turning everything into a bit."
+      },
+      "structured_background": {
+        "name": "Aaliyah",
+        "age": 22,
+        "gender": "female",
+        "job": "works as a diesel mechanic, learned from her dad",
+        "location": null,
+        "reason_for_calling": "caught their roommate in a hotel room that was supposed to be a business trip and now they can't make eye contact \u2014 the roommate acts like nothing happened but it was extremely age play-adjacent",
+        "pool_name": "PROBLEMS",
+        "communication_style": "COMMUNICATION STYLE: Treats the call like a set. Has bits prepared. Delivers serious information with a punchline chaser. Self-deprecating as a defense mechanism \u2014 makes fun of themselves before anyone else can. Energy level: high. When pushed back on, they deflect with humor. Getting a straight answer from them requires the host to push. Conversational tendency: turning everything into a bit.",
+        "energy_level": "medium",
+        "emotional_state": "calm",
+        "signature_detail": "asks the host questions back",
+        "situation_summary": "caught their roommate in a hotel room that was supposed to be a business trip and now they can't make eye contact \u2014 the ",
+        "natural_description": "22 years old. Works as a diesel mechanic, learned from her dad. Caught their roommate in a hotel room that was supposed to be a business trip and now they can't make eye contact \u2014 the roommate acts like nothing happened but it was extremely age play-adjacent. Was was in the bathtub, phone on the edge of the sink, show on speaker. before calling. Coyotes are going crazy outside right now Tells everyone they quit drinking but keeps a bottle in the garage behind the paint cans. Her coworker and friend denise, who she vents to on breaks. Believes poker is the most honest game there is because everybody's lying. Single, been that way a while. Not sure if by choice anymore.. Really into into gardening, talks to plants. Also into wildlife photography, has patience for it. Her boss karen \u2014 yes, her name is actually karen \u2014 who is actually cool. It's Monday night, the middle of the night. it's a weeknight \u2014 work tomorrow for most people. Early spring \u2014 wind season is starting. Dust storms possible.",
+        "seeds": [
+          "into gardening, talks to plants",
+          "into wildlife photography, has patience for it",
+          "asks the host questions back",
+          "Believes poker is the most honest game there is because everybody's lying."
+        ],
+        "verbal_fluency": "medium",
+        "calling_from": "at a rest area on I-25, halfway to Albuquerque"
+      },
+      "avatar": "Aaliyah.jpg",
+      "relationships": {},
+      "call_history": [
+        {
+          "summary": "Alia called in to share her discomfort after unexpectedly discovering her roommate engaging in age play while supposedly on a business trip. She expressed frustration over their awkward living situation and his refusal to acknowledge the incident, leading her to feel gaslit; however, by the end of the conversation, she realized she could address the issue directly to ease the tension between them.",
+          "timestamp": 1773647350.908658,
+          "arc_status": "ongoing"
+        }
+      ],
+      "last_call": 1773647350.908658,
+      "created_at": 1773647350.908658
+    }
+  ]
+}

data/session_checkpoint.json

@@ -0,0 +1,378 @@
+{
+  "session_id": "0d4a0098",
+  "call_history": [],
+  "caller_backgrounds": {
+    "1": {
+      "name": "Greg",
+      "age": 51,
+      "gender": "male",
+      "job": "does accounting for a small firm",
+      "location": null,
+      "reason_for_calling": "thinks the obsession with sourdough bread is ridiculous and a loaf from the store tastes the same",
+      "pool_name": "HOT_TAKES",
+      "communication_style": "COMMUNICATION STYLE: Bone dry. Says devastating things with zero inflection. Their humor sneaks up on you \u2014 you're not sure if they're joking until three seconds after they finish talking. Short, precise sentences. Never raises their voice. Energy level: low-medium. When pushed back on, they respond with one calm sentence that somehow makes the other person feel stupid. Conversational tendency: underreaction.",
+      "energy_level": "medium",
+      "emotional_state": "calm",
+      "signature_detail": "manic energy tonight, everything is hilarious or devastating",
+      "situation_summary": "thinks the obsession with sourdough bread is ridiculous and a loaf from the store tastes the same",
+      "natural_description": "51, does accounting for a small firm. Thinks the obsession with sourdough bread is ridiculous and a loaf from the store tastes the same. Tends to say \"mark my words.\" Sad and low energy. Perks up when the host engages. Leaves with a little more hope.. His best friend manny, known each other since middle school. Just got out of something. Not ready to talk about it. Or maybe they are.. Had Band of Brothers on before calling. Really into grows a massive garden, gives produce to half the neighborhood. Also watches Dateline and 48 Hours religiously, has theories about cold cases. Was was at waffle house at the counter by themselves, couldn't sleep. before calling. When they ran into someone from high school at the Walmart in Deming and it was awkward. Swears the sopapillas at the Adobe Deli in Deming are the best thing on the menu Lectures their kids about financial responsibility but is secretly $30,000 in credit card debt. Thinks too many people are afraid of silence. It's Monday night, afternoon. it's a weeknight \u2014 work tomorrow for most people. Early spring \u2014 wind season is starting. Dust storms possible.",
+      "seeds": [
+        "grows a massive garden, gives produce to half the neighborhood",
+        "watches Dateline and 48 Hours religiously, has theories about cold cases",
+        "manic energy tonight, everything is hilarious or devastating",
+        "Thinks too many people are afraid of silence."
+      ],
+      "verbal_fluency": "medium",
+      "calling_from": ""
+    },
+    "2": {
+      "name": "Candy",
+      "age": 39,
+      "gender": "female",
+      "job": "teaches kindergarten",
+      "location": null,
+      "reason_for_calling": "walked into the wrong house in their subdivision \u2014 same floor plan, door was unlocked \u2014 sat down on the couch before the actual homeowner came out of the bathroom",
+      "pool_name": "STORIES",
+      "communication_style": "COMMUNICATION STYLE: Called because they need to GET THIS OFF THEIR CHEST. Talks in capital letters. Uses 'honestly' and 'I'm not even kidding' a lot. The anger is specific and justified \u2014 this isn't random rage, this is 'let me tell you exactly what happened.' Energy level: very high. When pushed back on, they take a breath and say 'I hear you but...' and then get right back to the rant. Conversational tendency: building to a crescendo.",
+      "energy_level": "high",
+      "emotional_state": "calm",
+      "signature_detail": "no shame about their desires",
+      "situation_summary": "walked into the wrong house in their subdivision \u2014 same floor plan, door was unlocked \u2014 sat down on the couch before the",
+      "natural_description": "39, teaches kindergarten. Walked into the wrong house in their subdivision \u2014 same floor plan, door was unlocked \u2014 sat down on the couch before the actual homeowner came out of the bathroom. Called once before a while back. Thinks about it sometimes. Calling again because things changed.. Cheerful and joking at first. Using humor to avoid the real thing. Eventually drops the act.. Was was having a smoke outside and just started thinking. before calling. Her sister natalie, the one who always needs money. Her therapist, who she refers to by first name like they're friends. Fascinated by quantum physics, watches every pbs space time episode is their thing. Into reloading ammo, treats it like a science too. No shame about their desires. Goes to church every Sunday but has serious doubts they've never said out loud \u2014 not about God, about whether the people there actually believe any of it. Separated. Living apart but haven't filed yet.. When their dad took them hunting for the first time, out near the Peloncillos. It's Monday night, afternoon. it's a weeknight \u2014 work tomorrow for most people. Early spring \u2014 wind season is starting. Dust storms possible.",
+      "seeds": [
+        "fascinated by quantum physics, watches every PBS Space Time episode",
+        "into reloading ammo, treats it like a science",
+        "no shame about their desires",
+        "Believes aliens have definitely been to the bootheel. Not joking."
+      ],
+      "verbal_fluency": "medium",
+      "calling_from": "driving back from Silver City on NM-90"
+    },
+    "3": {
+      "name": "Vernon",
+      "age": 58,
+      "gender": "male",
+      "job": "is a pest control guy",
+      "location": null,
+      "reason_for_calling": "their tenant is three months behind on rent and has a newborn \u2014 the caller needs the rental income to pay their own mortgage but can't live with themselves for evicting a baby",
+      "pool_name": "ADVICE",
+      "communication_style": "COMMUNICATION STYLE: Treats the call like a set. Has bits prepared. Delivers serious information with a punchline chaser. Self-deprecating as a defense mechanism \u2014 makes fun of themselves before anyone else can. Energy level: high. When pushed back on, they deflect with humor. Getting a straight answer from them requires the host to push. Conversational tendency: turning everything into a bit.",
+      "energy_level": "medium",
+      "emotional_state": "calm",
+      "signature_detail": "will share details if you ask",
+      "situation_summary": "their tenant is three months behind on rent and has a newborn \u2014 the caller needs the rental income to pay their own mort",
+      "natural_description": "Is a pest control guy, 58. Their tenant is three months behind on rent and has a newborn \u2014 the caller needs the rental income to pay their own mortgage but can't live with themselves for evicting a baby. Had the classic rock station on earlier. Sad and low energy. Perks up when the host engages. Leaves with a little more hope.. The time the roof leaked during monsoon and they were up all night with buckets. Long-distance thing that probably isn't going to work but they keep trying.. Thinks too many people are afraid of silence. Has listened to the show a few times. Decided tonight was the night to finally call.. Will share details if you ask. Raised to believe men don't cry but breaks down alone in the truck at least once a month. His best friend manny, known each other since middle school. Tends to wander into unrelated stories when the main topic gets uncomfortable. Was was cleaning their gun at the kitchen table, it's a ritual that helps them think. before calling. Really into into camping and survival stuff. Also hooked on The Last of Us, compares it to the game constantly. It's Monday night, afternoon. it's a weeknight \u2014 work tomorrow for most people. Early spring \u2014 wind season is starting. Dust storms possible.",
+      "seeds": [
+        "into camping and survival stuff",
+        "hooked on The Last of Us, compares it to the game constantly",
+        "will share details if you ask",
+        "Thinks too many people are afraid of silence."
+      ],
+      "verbal_fluency": "medium",
+      "calling_from": "outside the Dollar General, only place open"
+    },
+    "4": "28, watching her coveralls tumble dry and trying to decide if she should drive the three hours to Tucson tomorrow for her mom's birthday or keep pretending her brother doesn't exist in unknown. Returning caller \u2014 a regular caller. \nRIGHT NOW: It's Monday night, afternoon. it's a weeknight \u2014 work tomorrow for most people.\nPEOPLE IN THEIR LIFE: Her best friend lena, who moved away last year and the distance is hard. Her husband david, high school sweetheart. Use their names when talking about them.\nVERBAL HABITS: Tends to say \"so yeah\" and \"and I told myself\" \u2014 use these naturally in conversation.\nRELATIONSHIP TO THE SHOW: Has called before. Comfortable on air. Knows Luke by name.\nPREVIOUS CALLS (your memory of calling this show before):\n- (1 week ago) Angie's dying mother wants her to have birthday dinner with her estranged brother Derek tomorrow, whom she hasn't spoken to in two years after he told their mother her cancer was \"God's way of getting her attention\" for voting for Biden. Despite her fear that Derek will say something hurtful during dinner and her past trauma from staying silent around him, Angie agrees to go and share cake with her mother, deciding to buy the relighting candles her mom loved when they were kids.\n- (4 days ago) Angie called back after having the birthday cake dinner with her dying mom, which went well, but her brother Derek cornered her afterward accusing her of convincing their mom to stop cancer treatment and demanding they both attend the next doctor's appointment together. Luke advised her to talk directly to her mom about what she actually wants and encouraged Angie to have real conversations about her mom's end-of-life thoughts while she still can, which Angie agreed to do the next morning.\n- (2 days ago) Angie called to say her mother initially decided to stop cancer treatment, but after Angie's brother Derek intervened, their mother is now reconsidering and wants both siblings at the doctor's appointment. Luke firmly told Angie that despite her frustration with Derek's influence, she needs to respect whatever decision her mother ultimately makes, even if it changes, and stop trying to control the situation.\nYou're calling back with an UPDATE on this same situation \u2014 something has changed or developed since your last call. Stay focused on this storyline. Do NOT invent a new unrelated problem.",
+    "5": {
+      "name": "Wendell",
+      "age": 50,
+      "gender": "male",
+      "job": "works at a brewery",
+      "location": null,
+      "reason_for_calling": "thinks bumper stickers are a cry for attention and nobody's ever changed their mind because of one",
+      "pool_name": "HOT_TAKES",
+      "communication_style": "COMMUNICATION STYLE: Starts a sentence, gets distracted by their own tangent, starts another sentence, remembers the first one, tries to merge them. Asks 'where was I?' a lot. Not unintelligent \u2014 their brain just moves faster than their mouth. Lots of 'oh and another thing.' Energy level: medium-high but unfocused. When pushed back on, they agree enthusiastically and then immediately go off on another tangent. Conversational tendency: free association.",
+      "energy_level": "medium",
+      "emotional_state": "calm",
+      "signature_detail": "uses metaphors for everything",
+      "situation_summary": "thinks bumper stickers are a cry for attention and nobody's ever changed their mind because of one",
+      "natural_description": "50 years old. Works at a brewery. Thinks bumper stickers are a cry for attention and nobody's ever changed their mind because of one. His ex-girlfriend kayla, who he ran into last month and hasn't stopped thinking about. Doesn't usually listen to this kind of show but stumbled on it tonight and something made them stay.. Thinks the monsoon season is the best time of year and people who complain about it are wrong. Was was closing up the shop, everyone else went home an hour ago. before calling. Into gamer, plays late at night after the house quiets down. Misses the old Denny's that used to be in Lordsburg, it wasn't good but it was there Claims to be an open book but there's a three-year gap in their life story that nobody's allowed to ask about. Using earbuds so nobody in the house hears His sister deb, who married money and acts like she forgot where she came from. Long-distance thing that probably isn't going to work but they keep trying.. Having having some chamomile tea, trying to wind down.. Earlier today: Went to the post office \u2014 package I've been waiting on finally came It's Monday night, afternoon. it's a weeknight \u2014 work tomorrow for most people. Early spring \u2014 wind season is starting. Dust storms possible.",
+      "seeds": [
+        "gamer, plays late at night after the house quiets down",
+        "restores old furniture from estate sales",
+        "uses metaphors for everything",
+        "Thinks the monsoon season is the best time of year and people who complain about it are wrong."
+      ],
+      "verbal_fluency": "medium",
+      "calling_from": ""
+    },
+    "6": {
+      "name": "Yolanda",
+      "age": 44,
+      "gender": "female",
+      "job": "drives an ambulance",
+      "location": null,
+      "reason_for_calling": "is being sued by their former business partner for $200k and just got served at their daughter's soccer game",
+      "pool_name": "PROBLEMS",
+      "communication_style": "COMMUNICATION STYLE: Clearly holding back. Gives vague answers to direct questions. Says 'I can't really get into that' about key details. The mystery IS the hook \u2014 makes you want to know what they're not saying. Energy level: low, controlled. When pushed back on, they deflect smoothly or change the subject. Getting the real story requires the host to work for it. Conversational tendency: strategic omission.",
+      "energy_level": "medium",
+      "emotional_state": "calm",
+      "signature_detail": "clearly rehearsed what to say but it's falling apart",
+      "situation_summary": "is being sued by their former business partner for $200k and just got served at their daughter's soccer game",
+      "natural_description": "44, drives an ambulance. Is being sued by their former business partner for $200k and just got served at their daughter's soccer game. Had Road House on before calling. Was was at waffle house at the counter by themselves, couldn't sleep. before calling. Clearly rehearsed what to say but it's falling apart. Her sister natalie, the one who always needs money. When a dust storm came through and they couldn't see ten feet in front of them. In the truck at the gas station \u2014 only place with good signal Married, 15 years. It's comfortable but sometimes that's the problem.. Really into obsessed with Severance, has theories about every floor. Also plays chess online, follows the competitive scene. Believes the desert teaches you things about yourself if you let it. Her mom diane, who she's been taking care of since the stroke. Doesn't usually listen to this kind of show but stumbled on it tonight and something made them stay.. It's Monday night, afternoon. it's a weeknight \u2014 work tomorrow for most people. Early spring \u2014 wind season is starting. Dust storms possible.",
+      "seeds": [
+        "obsessed with Severance, has theories about every floor",
+        "plays chess online, follows the competitive scene",
+        "clearly rehearsed what to say but it's falling apart",
+        "Believes the desert teaches you things about yourself if you let it."
+      ],
+      "verbal_fluency": "medium",
+      "calling_from": "pulled off on NM-9 south of Hachita, nothing around for miles"
+    },
+    "7": {
+      "name": "Big Mike",
+      "age": 54,
+      "gender": "male",
+      "job": "is a youth pastor",
+      "location": "in Animas",
+      "reason_for_calling": "completed their first full night of sleep without nightmares since coming home from deployment",
+      "pool_name": "CELEBRATIONS",
+      "communication_style": "COMMUNICATION STYLE: Comes in hot. Has an opinion about everything and isn't shy about sharing it. Interrupts. Disagrees first, thinks second. Not mean \u2014 just intense. Treats every conversation like a friendly argument. Energy level: high. When pushed back on, they lean IN, not away. They love a good debate and will take the opposite position just for sport. Conversational tendency: challenging everything.",
+      "energy_level": "medium",
+      "emotional_state": "calm",
+      "signature_detail": "pauses a lot, choosing words carefully",
+      "situation_summary": "completed their first full night of sleep without nightmares since coming home from deployment",
+      "natural_description": "Is a youth pastor in Animas, 54. Completed their first full night of sleep without nightmares since coming home from deployment. Starts guarded and vague. Opens up after the host earns trust. Gets real once comfortable.. In a relationship, about 3 years. She wants to get married, they're not sure.. His brother daryl, who always has some scheme going. Tells everyone they love small-town life but applies for jobs in other states every few months and never follows through. Swears the green chile at Sparky's in Hatch is the best you'll ever have Calling from the motel room, walls are thin so they're whispering Pauses a lot, choosing words carefully. Spends free time on does competitive shooting, three-gun matches on weekends. Was was laying in a hammock out back, couldn't go inside. before calling. It's Monday night, afternoon. it's a weeknight \u2014 work tomorrow for most people. Early spring \u2014 wind season is starting. Dust storms possible.\nABOUT WHERE THEY LIVE (Animas): Tiny ranching community in the Animas Valley, very remote. Maybe 250 people. Mostly cattle ranches and open desert. No stores, no restaurants, no bars. You drive to Lordsburg for groceries. Incredible dark skies. Peloncillo Mountains to the west. Only reference real places and facts about this area \u2014 don't invent businesses or landmarks that aren't mentioned here.",
+      "seeds": [
+        "does competitive shooting, three-gun matches on weekends",
+        "brews beer at home, entered a few competitions",
+        "pauses a lot, choosing words carefully",
+        "Believes poker is the most honest game there is because everybody's lying."
+      ],
+      "verbal_fluency": "medium",
+      "calling_from": "laundromat, waiting on the dryer"
+    },
+    "8": {
+      "name": "Luann",
+      "age": 49,
+      "gender": "female",
+      "job": "is an accountant at a small firm",
+      "location": null,
+      "reason_for_calling": "best friend from high school died in a car wreck last month and they hadn't talked in three years because of a stupid argument",
+      "pool_name": "PROBLEMS",
+      "communication_style": "COMMUNICATION STYLE: Amped up. Talks fast, laughs loud, jumps between topics like they've had five espressos. Infectious enthusiasm \u2014 even bad news sounds exciting when they tell it. Uses exclamation energy without actually exclaiming. Energy level: very high. When pushed back on, they get even MORE animated and start talking with their hands (you can hear it). Conversational tendency: escalation.",
+      "energy_level": "high",
+      "emotional_state": "calm",
+      "signature_detail": "interrupts themselves mid-thought",
+      "situation_summary": "best friend from high school died in a car wreck last month and they hadn't talked in three years because of a stupid ar",
+      "natural_description": "49, is an accountant at a small firm. Best friend from high school died in a car wreck last month and they hadn't talked in three years because of a stupid argument. Calling from outside \u2014 better signal out here Earlier today: Just got back from Walmart in Deming \u2014 hour round trip for groceries The time they helped a stranger change a tire on I-10 in 110 degree heat. Separated. Living apart but haven't filed yet.. Was was lying in bed staring at the ceiling when the show came on. before calling. Her husband david, high school sweetheart. Follows jwst discoveries, has opinions about exoplanet findings is their thing. Serious about astrophotography, does long exposures in the desert too. Having eating sunflower seeds, spitting shells into a cup.. Judges people who go to therapy but has been journaling every night for years \u2014 basically doing therapy alone in their kitchen. Thinks too many people are afraid of silence. Interrupts themselves mid-thought. It's Monday night, afternoon. it's a weeknight \u2014 work tomorrow for most people. Early spring \u2014 wind season is starting. Dust storms possible.",
+      "seeds": [
+        "follows JWST discoveries, has opinions about exoplanet findings",
+        "serious about astrophotography, does long exposures in the desert",
+        "interrupts themselves mid-thought",
+        "Thinks too many people are afraid of silence."
+      ],
+      "verbal_fluency": "medium",
+      "calling_from": ""
+    },
+    "9": {
+      "name": "Benny",
+      "age": 32,
+      "gender": "male",
+      "job": "runs a junkyard",
+      "location": null,
+      "reason_for_calling": "slept with their best friend's spouse at that friend's funeral reception \u2014 they were both grief-drunk and now they see each other every week because they're both in the dead friend's will as co-executors",
+      "pool_name": "PROBLEMS",
+      "communication_style": "COMMUNICATION STYLE: Quiet, a little nervous. Short sentences, lots of pauses. Doesn't volunteer information \u2014 you have to pull it out of them. When they do open up it comes out in a rush. Gets flustered by direct questions. Tends to backtrack and qualify everything they say. Energy level: low. When pushed back on, they fold quickly and agree even if they don't mean it. Conversational tendency: understatement.",
+      "energy_level": "medium",
+      "emotional_state": "calm",
+      "signature_detail": "laughs at their own pain as a coping mechanism",
+      "situation_summary": "slept with their best friend's spouse at that friend's funeral reception \u2014 they were both grief-drunk and now they see e",
+      "natural_description": "32, runs a junkyard. Slept with their best friend's spouse at that friend's funeral reception \u2014 they were both grief-drunk and now they see each other every week because they're both in the dead friend's will as co-executors. Friend told them about the show and dared them to call in.. Tends to say \"so I'm standing there.\" Connects everything back to a TV show they're watching. In a relationship, about 3 years. She wants to get married, they're not sure.. Drives a minivan. Thinks Diane's Restaurant in Silver City is overrated, doesn't care who disagrees Angry and blaming others at first. Slowly realizes their own role in it. Hard to admit.. His buddy ray from work, the one person he trusts. Was was at waffle house at the counter by themselves, couldn't sleep. before calling. His cousin ruben, more like a brother really. Says money doesn't matter but lost a friendship over $200 and still thinks about it. Comfortable with their body is their thing. Has experimented, open about it too. It's Monday night, afternoon. it's a weeknight \u2014 work tomorrow for most people. Early spring \u2014 wind season is starting. Dust storms possible.",
+      "seeds": [
+        "comfortable with their body",
+        "has experimented, open about it",
+        "laughs at their own pain as a coping mechanism",
+        "Believes poker is the most honest game there is because everybody's lying."
+      ],
+      "verbal_fluency": "medium",
+      "calling_from": ""
+    },
+    "0": {
+      "name": "Sandy",
+      "age": 64,
+      "gender": "female",
+      "job": "works as a bartender at a dive bar",
+      "location": "in Phoenix",
+      "reason_for_calling": "accidentally waved back at someone who was waving at the person behind them \u2014 committed to it and had a five-minute conversation pretending they knew each other, exchanged numbers, and is now too deep to explain",
+      "pool_name": "STORIES",
+      "communication_style": "COMMUNICATION STYLE: Quiet, a little nervous. Short sentences, lots of pauses. Doesn't volunteer information \u2014 you have to pull it out of them. When they do open up it comes out in a rush. Gets flustered by direct questions. Tends to backtrack and qualify everything they say. Energy level: low. When pushed back on, they fold quickly and agree even if they don't mean it. Conversational tendency: understatement.",
+      "energy_level": "medium",
+      "emotional_state": "calm",
+      "signature_detail": "comfortable talking about sex when it comes up",
+      "situation_summary": "accidentally waved back at someone who was waving at the person behind them \u2014 committed to it and had a five-minute conv",
+      "natural_description": "Works as a bartender at a dive bar in Phoenix, 64. Accidentally waved back at someone who was waving at the person behind them \u2014 committed to it and had a five-minute conversation pretending they knew each other, exchanged numbers, and is now too deep to explain. Her ex-husband danny, he's still in the picture because of the kids. Been binging landman, loves the oil field drama is their thing. Coaches youth sports, takes it more seriously than the parents do too. Convinced the government knows about things in the desert they won't talk about. Cheerful and joking at first. Using humor to avoid the real thing. Eventually drops the act.. Divorced twice. Not in a rush to do it again.. Drives a Ram. Was was at a truck stop diner, cup of coffee, staring out the window. before calling. Comfortable talking about sex when it comes up. Her friend tammy from church, the only one who knows the real story. Acts practical and no-nonsense but believes in ghosts. Has a story about it that they only tell late at night. First-time caller. Nervous about being on the radio. Almost hung up before they got through.. Tends to say \"it hit me like a truck.\" Their first real fight, in the parking lot of a bar in Lordsburg. They lost. It's Monday night, afternoon. it's a weeknight \u2014 work tomorrow for most people. Early spring \u2014 wind season is starting. Dust storms possible.",
+      "seeds": [
+        "been binging Landman, loves the oil field drama",
+        "coaches youth sports, takes it more seriously than the parents do",
+        "comfortable talking about sex when it comes up",
+        "Convinced the government knows about things in the desert they won't talk about."
+      ],
+      "verbal_fluency": "medium",
+      "calling_from": "in the bathtub, phone balanced on the edge"
+    }
+  },
+  "used_reasons": [
+    "their car's trip odometer resets itself to 0.0 every time they park at the grocery store \u2014 only at the grocery store, nowhere else \u2014 and it's been doing it for five months since they had the oil changed",
+    "their car radio turned itself on in the driveway at 2 AM playing a station that went off the air in 2003 \u2014 they checked, the station doesn't exist anymore",
+    "their church raised enough to pay off a family's medical debt anonymously",
+    "is being sued by their former business partner for $200k and just got served at their daughter's soccer game",
+    "walked into the wrong house in their subdivision \u2014 same floor plan, door was unlocked \u2014 sat down on the couch before the actual homeowner came out of the bathroom",
+    "found out their coworker who drives a new BMW and wears designer clothes is completely broke \u2014 the coworker accidentally left a bank statement on the printer showing a negative balance",
+    "their tenant is three months behind on rent and has a newborn \u2014 the caller needs the rental income to pay their own mortgage but can't live with themselves for evicting a baby",
+    "thinks couples who share a single social media account are hiding something and everyone knows it",
+    "had a near-death experience during a flash flood in a wash and the way time slowed down changed something fundamental in how they see each day",
+    "their town's only restaurant changed the recipe for the green chile and there's a petition with 200 signatures demanding they change it back \u2014 the caller started the petition",
+    "slept with their best friend's spouse at that friend's funeral reception \u2014 they were both grief-drunk and now they see each other every week because they're both in the dead friend's will as co-executors",
+    "their town had a power outage and everyone went outside and hung out in the street for three hours \u2014 it was the best night they've had in years and they're weirdly hoping it happens again",
+    "has been having phone sex with a stranger they met on a late-night chat line for six months \u2014 they know the person's voice better than their spouse's and they've started comparing the two out loud by accident",
+    "thinks the obsession with sourdough bread is ridiculous and a loaf from the store tastes the same",
+    "best friend from high school died in a car wreck last month and they hadn't talked in three years because of a stupid argument",
+    "accidentally waved back at someone who was waving at the person behind them \u2014 committed to it and had a five-minute conversation pretending they knew each other, exchanged numbers, and is now too deep to explain",
+    "thinks bumper stickers are a cry for attention and nobody's ever changed their mind because of one",
+    "completed their first full night of sleep without nightmares since coming home from deployment"
+  ],
+  "ai_respond_mode": "manual",
+  "auto_followup": false,
+  "news_headlines": [],
+  "research_notes": {},
+  "caller_bases": {
+    "1": {
+      "name": "Greg",
+      "voice": "Timothy",
+      "returning": false,
+      "regular_id": null
+    },
+    "2": {
+      "name": "Candy",
+      "voice": "Kelsey",
+      "returning": false,
+      "regular_id": null
+    },
+    "3": {
+      "name": "Vernon",
+      "voice": "Vinny",
+      "returning": false,
+      "regular_id": null
+    },
+    "4": {
+      "name": "Angie",
+      "voice": "Julia",
+      "returning": true,
+      "regular_id": "bbb20b67"
+    },
+    "5": {
+      "name": "Wendell",
+      "voice": "Hank",
+      "returning": false,
+      "regular_id": null
+    },
+    "6": {
+      "name": "Yolanda",
+      "voice": "Lauren",
+      "returning": false,
+      "regular_id": null
+    },
+    "7": {
+      "name": "Big Mike",
+      "voice": "Edward",
+      "returning": false,
+      "regular_id": null
+    },
+    "8": {
+      "name": "Luann",
+      "voice": "Serena",
+      "returning": false,
+      "regular_id": null
+    },
+    "9": {
+      "name": "Benny",
+      "voice": "Clive",
+      "returning": false,
+      "regular_id": null
+    },
+    "0": {
+      "name": "Sandy",
+      "voice": "Loretta",
+      "returning": false,
+      "regular_id": null
+    }
+  },
+  "pool_weights": {
+    "PROBLEMS": 0.23240905322989075,
+    "STORIES": 0.1759722154274807,
+    "GOSSIP": 0.14602822326391124,
+    "ADVICE": 0.12409358363552739,
+    "TOPIC_CALLIN": 0.09667013948808895,
+    "CELEBRATIONS": 0.07603761096793717,
+    "WEIRD": 0.14878917398716374
+  },
+  "caller_styles": {
+    "1": "COMMUNICATION STYLE: Bone dry. Says devastating things with zero inflection. Their humor sneaks up on you \u2014 you're not sure if they're joking until three seconds after they finish talking. Short, precise sentences. Never raises their voice. Energy level: low-medium. When pushed back on, they respond with one calm sentence that somehow makes the other person feel stupid. Conversational tendency: underreaction.",
+    "2": "COMMUNICATION STYLE: Called because they need to GET THIS OFF THEIR CHEST. Talks in capital letters. Uses 'honestly' and 'I'm not even kidding' a lot. The anger is specific and justified \u2014 this isn't random rage, this is 'let me tell you exactly what happened.' Energy level: very high. When pushed back on, they take a breath and say 'I hear you but...' and then get right back to the rant. Conversational tendency: building to a crescendo.",
+    "3": "COMMUNICATION STYLE: Treats the call like a set. Has bits prepared. Delivers serious information with a punchline chaser. Self-deprecating as a defense mechanism \u2014 makes fun of themselves before anyone else can. Energy level: high. When pushed back on, they deflect with humor. Getting a straight answer from them requires the host to push. Conversational tendency: turning everything into a bit.",
+    "4": "COMMUNICATION STYLE: Bone dry. Says devastating things with zero inflection. Their humor sneaks up on you \u2014 you're not sure if they're joking until three seconds after they finish talking. Short, precise sentences. Never raises their voice. Energy level: low-medium. When pushed back on, they respond with one calm sentence that somehow makes the other person feel stupid. Conversational tendency: underreaction.",
+    "5": "COMMUNICATION STYLE: Starts a sentence, gets distracted by their own tangent, starts another sentence, remembers the first one, tries to merge them. Asks 'where was I?' a lot. Not unintelligent \u2014 their brain just moves faster than their mouth. Lots of 'oh and another thing.' Energy level: medium-high but unfocused. When pushed back on, they agree enthusiastically and then immediately go off on another tangent. Conversational tendency: free association.",
+    "6": "COMMUNICATION STYLE: Clearly holding back. Gives vague answers to direct questions. Says 'I can't really get into that' about key details. The mystery IS the hook \u2014 makes you want to know what they're not saying. Energy level: low, controlled. When pushed back on, they deflect smoothly or change the subject. Getting the real story requires the host to work for it. Conversational tendency: strategic omission.",
+    "7": "COMMUNICATION STYLE: Comes in hot. Has an opinion about everything and isn't shy about sharing it. Interrupts. Disagrees first, thinks second. Not mean \u2014 just intense. Treats every conversation like a friendly argument. Energy level: high. When pushed back on, they lean IN, not away. They love a good debate and will take the opposite position just for sport. Conversational tendency: challenging everything.",
+    "8": "COMMUNICATION STYLE: Amped up. Talks fast, laughs loud, jumps between topics like they've had five espressos. Infectious enthusiasm \u2014 even bad news sounds exciting when they tell it. Uses exclamation energy without actually exclaiming. Energy level: very high. When pushed back on, they get even MORE animated and start talking with their hands (you can hear it). Conversational tendency: escalation.",
+    "9": "COMMUNICATION STYLE: Quiet, a little nervous. Short sentences, lots of pauses. Doesn't volunteer information \u2014 you have to pull it out of them. When they do open up it comes out in a rush. Gets flustered by direct questions. Tends to backtrack and qualify everything they say. Energy level: low. When pushed back on, they fold quickly and agree even if they don't mean it. Conversational tendency: understatement.",
+    "0": "COMMUNICATION STYLE: Quiet, a little nervous. Short sentences, lots of pauses. Doesn't volunteer information \u2014 you have to pull it out of them. When they do open up it comes out in a rush. Gets flustered by direct questions. Tends to backtrack and qualify everything they say. Energy level: low. When pushed back on, they fold quickly and agree even if they don't mean it. Conversational tendency: understatement."
+  },
+  "caller_shapes": {
+    "1": "standard",
+    "2": "confrontation",
+    "3": "standard",
+    "5": "am_i_the_asshole",
+    "6": "confrontation",
+    "7": "escalating_reveal",
+    "8": "quick_hit",
+    "9": "escalating_reveal",
+    "0": "am_i_the_asshole"
+  },
+  "tone_streak": [
+    "light",
+    "light",
+    "light",
+    "light",
+    "light",
+    "light",
+    "heavy",
+    "light",
+    "light",
+    "light",
+    "light",
+    "heavy",
+    "heavy",
+    "light",
+    "light",
+    "light",
+    "heavy",
+    "heavy"
+  ],
+  "call_quality_signals": [],
+  "caller_queue": [
+    "1",
+    "2",
+    "3",
+    "8",
+    "4",
+    "5",
+    "7",
+    "9",
+    "0",
+    "6"
+  ],
+  "relationship_context": {},
+  "intern_monitoring": true,
+  "costs": {
+    "total_cost_usd": 0.0,
+    "llm_cost_usd": 0.0,
+    "tts_cost_usd": 0.0,
+    "total_llm_calls": 0,
+    "total_tokens": 0,
+    "prompt_tokens": 0,
+    "completion_tokens": 0,
+    "by_category": {}
+  },
+  "saved_at": 1773697751.162024
+}

data/voicemails.json

@@ -0,0 +1,15 @@
+{
+  "voicemails": [],
+  "deleted_timestamps": [
+    1772294240,
+    1771212705,
+    1771146434,
+    1771146564,
+    1773545733,
+    1771146952,
+    1773531209,
+    1771244817,
+    1771244823,
+    1771213151
+  ]
+}

deploy_stats_cron.sh

@@ -0,0 +1,77 @@
+#!/bin/bash
+# Deploy podcast_stats.py to NAS as a long-running Docker container that updates hourly.
+#
+# Usage: ./deploy_stats_cron.sh
+
+set -e
+
+NAS_HOST="mmgnas-10g"
+NAS_USER="luke"
+NAS_PORT="8001"
+DOCKER_BIN="/share/CACHEDEV1_DATA/.qpkg/container-station/bin/docker"
+DEPLOY_DIR="/share/CACHEDEV1_DATA/podcast-stats"
+CONTAINER_NAME="podcast-stats"
+
+echo "Deploying podcast stats to NAS..."
+
+# Create deploy dir and copy files
+ssh -p "$NAS_PORT" "$NAS_USER@$NAS_HOST" "mkdir -p $DEPLOY_DIR"
+scp -P "$NAS_PORT" podcast_stats.py "$NAS_USER@$NAS_HOST:$DEPLOY_DIR/podcast_stats.py"
+
+# Create Dockerfile locally, then copy it over (NAS /tmp is tiny)
+TMPFILE=$(mktemp)
+cat > "$TMPFILE" << 'DOCKERFILE'
+FROM python:3.11-slim
+RUN apt-get update && apt-get install -y --no-install-recommends curl && rm -rf /var/lib/apt/lists/* \
+    && curl -fsSL https://download.docker.com/linux/static/stable/x86_64/docker-27.5.1.tgz | tar xz --strip-components=1 -C /usr/local/bin docker/docker
+RUN pip install --no-cache-dir requests yt-dlp
+COPY podcast_stats.py /app/podcast_stats.py
+COPY run_loop.sh /app/run_loop.sh
+RUN chmod +x /app/run_loop.sh
+WORKDIR /app
+CMD ["/app/run_loop.sh"]
+DOCKERFILE
+scp -P "$NAS_PORT" "$TMPFILE" "$NAS_USER@$NAS_HOST:$DEPLOY_DIR/Dockerfile"
+rm "$TMPFILE"
+
+# Create the loop script
+TMPFILE=$(mktemp)
+cat > "$TMPFILE" << 'LOOPSCRIPT'
+#!/bin/sh
+echo "podcast-stats: starting hourly loop"
+while true; do
+    echo "$(date -u '+%Y-%m-%dT%H:%M:%SZ') Running stats update..."
+    if python podcast_stats.py --json --upload 2>&1; then
+        [ -n "$HEARTBEAT_URL" ] && curl -s "${HEARTBEAT_URL}?status=up&msg=OK" > /dev/null
+        echo "  ...done, heartbeat sent"
+    else
+        echo "  ...failed, will retry next hour"
+    fi
+    echo "Sleeping 1 hour..."
+    sleep 3600
+done
+LOOPSCRIPT
+scp -P "$NAS_PORT" "$TMPFILE" "$NAS_USER@$NAS_HOST:$DEPLOY_DIR/run_loop.sh"
+rm "$TMPFILE"
+
+echo "Building Docker image on NAS..."
+ssh -p "$NAS_PORT" "$NAS_USER@$NAS_HOST" \
+    "TMPDIR=$DEPLOY_DIR $DOCKER_BIN build -t $CONTAINER_NAME $DEPLOY_DIR"
+
+# Stop old container if running
+ssh -p "$NAS_PORT" "$NAS_USER@$NAS_HOST" \
+    "$DOCKER_BIN rm -f $CONTAINER_NAME 2>/dev/null || true"
+
+# Run as a daemon with auto-restart (survives reboots)
+echo "Starting container..."
+ssh -p "$NAS_PORT" "$NAS_USER@$NAS_HOST" \
+    "$DOCKER_BIN run -d --name $CONTAINER_NAME --restart unless-stopped --network host -v /var/run/docker.sock:/var/run/docker.sock $CONTAINER_NAME"
+
+echo "Verifying..."
+sleep 3
+ssh -p "$NAS_PORT" "$NAS_USER@$NAS_HOST" \
+    "$DOCKER_BIN logs $CONTAINER_NAME 2>&1 | tail -5"
+
+echo ""
+echo "Done! Container runs hourly in a loop with --restart unless-stopped."
+echo "  Logs: ssh -p $NAS_PORT $NAS_USER@$NAS_HOST '$DOCKER_BIN logs -f $CONTAINER_NAME'"

docs/architecture.md

@@ -0,0 +1,361 @@
+# Luke at the Roost — Architecture
+
+## System Overview
+
+```
+┌─────────────────────────────────────────────────────────────────────────┐
+│                        BROWSER (Control Panel)                          │
+│                                                                         │
+│  ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌────────┐ ┌───────────────┐  │
+│  │ Caller   │ │  Chat    │ │  Music/  │ │Settings│ │  Server Log   │  │
+│  │ Buttons  │ │  Window  │ │  Ads/SFX │ │ Modal  │ │  (live tail)  │  │
+│  │ (0-9)    │ │          │ │          │ │        │ │               │  │
+│  └────┬─────┘ └────┬─────┘ └────┬─────┘ └───┬────┘ └───────┬───────┘  │
+│       │            │            │            │              │           │
+│  ┌────┴────────────┴────────────┴────────────┴──────────────┴───────┐  │
+│  │                    frontend/js/app.js                             │  │
+│  │  Polling: queue (3s), chat updates (real-time), logs (1s)        │  │
+│  │  Push-to-talk: record/stop → transcribe → chat → TTS → play     │  │
+│  └──────────────────────────┬───────────────────────────────────────┘  │
+└─────────────────────────────┼───────────────────────────────────────────┘
+                              │ REST API + WebSocket
+                              ▼
+┌─────────────────────────────────────────────────────────────────────────┐
+│                     FastAPI Backend (main.py)                            │
+│                     uvicorn :8000                                        │
+└─────────────────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## Caller Generation Pipeline
+
+```
+Session Reset / First Access to Caller Slot
+    │
+    ▼
+_randomize_callers()
+    │  Assigns unique names (from 24M/24F pool) and voices (Inworld: 14M/11F, ElevenLabs: 14M/8F) to 10 slots
+    │
+    ▼
+generate_caller_background(base)
+    │
+    ├─ Demographics: age (from range), job (gendered pool), location
+    │                                                        │
+    │                              ┌─────────────────────────┘
+    │                              ▼
+    │                     pick_location()
+    │                     80% LOCATIONS_LOCAL (weighted: Animas, Lordsburg)
+    │                     20% LOCATIONS_OUT_OF_STATE
+    │                              │
+    │                              ▼
+    │                     _get_town_from_location()
+    │                     └─ TOWN_KNOWLEDGE[town]
+    │                        32 towns with real facts
+    │                        "Only reference real places..."
+    │
+    ├─ 70% → PROBLEMS (100+ templates)
+    │        Fill {affair_person}, {fantasy_subject}, etc. from PROBLEM_FILLS
+    │
+    ├─ 30% → TOPIC_CALLIN (61 entries)
+    │        Prestige TV, science, poker, photography, physics, US news
+    │
+    ├─ 2x random INTERESTS (86 entries: TV shows, science, tech, poker, etc.)
+    │
+    └─ 2x random QUIRKS (conversational style traits)
+    │
+    ▼
+Result: "43, works IT for the city in Lordsburg. Just finished Severance
+        season 2... Follows JWST discoveries... Deflects with humor...
+        ABOUT WHERE THEY LIVE (Lordsburg): Small town on I-10, about 2,500
+        people... Only reference real places..."
+```
+
+### News Enrichment (at pickup time)
+
+```
+POST /api/call/{key}
+    │
+    ▼
+enrich_caller_background(background)     ← 5s timeout, fails silently
+    │
+    ├─ _extract_search_query(background)
+    │   ├─ Check _TOPIC_SEARCH_MAP (50+ keyword→query mappings)
+    │   │   "severance" → "Severance TV show"
+    │   │   "quantum"   → "quantum physics research"
+    │   │   "poker"     → "poker tournament"
+    │   │
+    │   └─ Fallback: extract keywords from problem sentence
+    │
+    ▼
+SearXNG (localhost:8888)
+    │  /search?q=...&format=json&categories=news
+    │
+    ▼
+LLM summarizes headline+snippet → natural one-liner
+    │  "Recently read about how Severance ties up the Lumon mystery"
+    │
+    ▼
+Appended to background: "..., and it's been on their mind."
+```
+
+---
+
+## AI Caller Conversation Flow
+
+```
+    Host speaks (push-to-talk or type)
+        │
+        ▼
+POST /api/record/start → record from input device
+POST /api/record/stop  → transcribe (Whisper @ 16kHz)
+        │
+        ▼
+POST /api/chat { text }
+        │
+        ├─ session.add_message("user", text)
+        │
+        ├─ Build system prompt: get_caller_prompt()
+        │   ├─ Caller identity + background + town knowledge
+        │   ├─ Show history (summaries of previous callers)
+        │   ├─ Conversation summary (last 6 messages)
+        │   └─ HOW TO TALK rules (varied length, no rehashing, etc.)
+        │
+        ├─ Last 10 messages → _normalize_messages_for_llm()
+        │
+        ▼
+LLMService.generate(messages, system_prompt)
+        │
+        ├─ OpenRouter: primary model (15s timeout)
+        ├─ Fallback 1: gemini-flash-1.5 (10s)
+        ├─ Fallback 2: gpt-4o-mini (10s)
+        ├─ Fallback 3: llama-3.1-8b (10s)
+        └─ Last resort: "Sorry, I totally blanked out..."
+        │
+        ▼
+clean_for_tts()              → strip (actions), *gestures*, fix phonetics
+ensure_complete_thought()    → trim to last complete sentence
+        │
+        ▼
+Response returned to frontend
+        │
+        ▼
+POST /api/tts { text, voice_id }
+        │
+        ▼
+generate_speech(text, voice_id)
+        │
+        ├─ Inworld (default cloud)     ─┐
+        ├─ ElevenLabs (cloud)           │
+        ├─ F5-TTS (local, cloned)       ├─→ PCM audio bytes (24kHz)
+        ├─ Kokoro MLX (local, fast)     │
+        ├─ ChatTTS / StyleTTS2 / etc.  ─┘
+        │
+        ▼
+AudioService.play_caller_audio(bytes, 24000)
+        │
+        └─→ Output Device Channel 1 (caller TTS)
+```
+
+---
+
+## Real Caller (Phone) Flow
+
+```
+Caller dials 208-439-LUKE
+        │
+        ▼
+SignalWire routes to webhook
+        │
+        ▼
+POST /api/signalwire/voice
+        │
+        ├─ If OFF AIR → play message + hangup
+        │
+        └─ If ON AIR → return BXML:
+           <Stream url="wss://.../api/signalwire/stream" codec="L16@16000h">
+        │
+        ▼
+WebSocket /api/signalwire/stream connects
+        │
+        ├─ "start" event → add to queue, play ring SFX
+        │                   broadcast_event("caller_queued")
+        │
+        │   [Caller waits in queue until host takes them]
+        │
+        ├─ Host clicks "Take Call" in UI
+        │   POST /api/queue/take/{caller_id}
+        │   └─ CallerService.take_call() → allocate channel
+        │   └─ Start host mic streaming → _host_audio_sender()
+        │
+        ├─ "media" events (continuous) ← caller's voice
+        │   │
+        │   ├─ route_real_caller_audio(pcm) → Ch 9 (host monitoring)
+        │   │
+        │   └─ Buffer 3s chunks → transcribe (Whisper)
+        │       │
+        │       └─ broadcast_chat() → appears in chat window
+        │
+        │   Host mic audio → _host_audio_sync_callback()
+        │   │
+        │   └─ _host_audio_sender() → CallerService.send_audio_to_caller()
+        │       └─ base64 encode → WebSocket → SignalWire → caller's phone
+        │
+        │   If AI caller also active (auto-respond mode):
+        │   │
+        │   └─ _debounced_auto_respond() (4s silence)
+        │       └─ LLM → TTS → play on Ch 1 + stream to real caller
+        │
+        ├─ Host hangs up
+        │   POST /api/hangup/real
+        │   └─ _signalwire_end_call(call_sid) → end phone call
+        │   └─ _summarize_real_call() → LLM summary → call_history
+        │   └─ Optional: _auto_followup() → pick AI caller to continue
+        │
+        └─ "stop" event or disconnect → cleanup
+```
+
+---
+
+## Audio Routing (Multi-Channel Output)
+
+```
+All audio goes to ONE physical output device (Loopback/interface)
+Each content type on a separate channel for mixing in DAW/OBS
+
+┌─────────────────────────────────────────────────────────────┐
+│                   Output Device (e.g. Loopback 16ch)        │
+│                                                             │
+│   Ch 1  ◄── Caller TTS (AI voices)          play_caller_audio()
+│   Ch 2  ◄── Music (loops)                   play_music()
+│   Ch 3  ◄── Sound Effects (one-shots)       play_sfx()
+│   Ch 9  ◄── Live Caller Audio (monitoring)  route_real_caller_audio()
+│   Ch 11 ◄── Ads (one-shots, no loop)        play_ad()
+│                                                             │
+│   All channels configurable via Settings panel              │
+└─────────────────────────────────────────────────────────────┘
+
+┌─────────────────────────────────────────────────────────────┐
+│                   Input Device (mic/interface)               │
+│                                                             │
+│   Ch N  ──► Host mic recording (push-to-talk)               │
+│         ──► Host mic streaming (to real callers via WS)     │
+└─────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## External Services
+
+```
+┌──────────────┐     ┌──────────────┐     ┌──────────────┐
+│  SignalWire   │     │  OpenRouter   │     │   SearXNG    │
+│              │     │              │     │  (local)     │
+│  Phone calls │     │  LLM API     │     │  News search │
+│  REST + WS   │     │  Claude,GPT  │     │  :8888       │
+│  Bidirectional│     │  Gemini,Llama│     │              │
+│  audio stream│     │  Fallback    │     │              │
+└──────────────┘     └──────────────┘     └──────────────┘
+
+┌──────────────┐     ┌──────────────┐     ┌──────────────┐
+│   Inworld    │     │  ElevenLabs  │     │  Local TTS   │
+│              │     │              │     │              │
+│  TTS (cloud) │     │  TTS (cloud) │     │  Kokoro MLX  │
+│  Default     │     │  Premium     │     │  F5-TTS      │
+│  provider    │     │              │     │  ChatTTS     │
+│              │     │              │     │  + others    │
+└──────────────┘     └──────────────┘     └──────────────┘
+
+┌──────────────┐
+│  Castopod    │
+│              │
+│  Podcast     │
+│  publishing  │
+│  (NAS)       │
+└──────────────┘
+```
+
+---
+
+## Session Lifecycle
+
+```
+New Session (reset)
+    │
+    ├─ Randomize all 10 caller names + voices
+    ├─ Clear conversation, call history, research
+    ├─ New session ID
+    │
+    ▼
+Show goes ON AIR (toggle)
+    │
+    ├─ SignalWire starts accepting calls
+    │
+    ▼
+Caller interactions (loop)
+    │
+    ├─ Pick AI caller (click button 0-9)
+    │   ├─ Generate background (if first time this session)
+    │   ├─ Enrich with news (SearXNG → LLM summary)
+    │   ├─ Conversation loop (chat/respond/auto-respond)
+    │   └─ Hangup → summarize → add to call_history
+    │
+    ├─ Take real caller from queue
+    │   ├─ Route audio both directions
+    │   ├─ Transcribe caller speech in real-time
+    │   ├─ Optional: AI caller auto-responds to real caller
+    │   └─ Hangup → summarize → add to call_history
+    │
+    ├─ Play music / ads / SFX between calls
+    │
+    └─ Each new caller sees show_history (summaries of all previous calls)
+        "EARLIER IN THE SHOW: Tony talked about... Carmen discussed..."
+    │
+    ▼
+Show goes OFF AIR
+    │
+    └─ Incoming calls get off-air message + hangup
+```
+
+---
+
+## Key Design Patterns
+
+| Pattern | Where | Why |
+|---------|-------|-----|
+| **Epoch-based staleness** | `_session_epoch` in main.py | Prevents stale LLM/TTS responses from playing after hangup |
+| **Fallback chain** | LLMService | Guarantees a response even if primary model times out |
+| **Debounced auto-respond** | `_debounced_auto_respond()` | Waits 4s for real caller to stop talking before AI jumps in |
+| **Silent failure** | News enrichment | If search/LLM fails, caller just doesn't have news context |
+| **Threading for audio** | `play_caller_audio()` | Audio playback can't block the async event loop |
+| **Ring buffer** | `route_real_caller_audio()` | Absorbs jitter in real caller audio stream |
+| **Lock contention guard** | `_ai_response_lock` | Only one AI response generates at a time |
+| **Town knowledge injection** | `TOWN_KNOWLEDGE` dict | Prevents LLM from inventing fake local businesses |
+
+---
+
+## File Map
+
+```
+ai-podcast/
+├── backend/
+│   ├── main.py              ← FastAPI app, all endpoints, caller generation, session
+│   ├── config.py            ← Settings (env vars, paths)
+│   └── services/
+│       ├── audio.py         ← Multi-channel audio I/O (sounddevice)
+│       ├── caller_service.py← Phone queue, WebSocket registry, audio routing
+│       ├── llm.py           ← OpenRouter/Ollama with fallback chain
+│       ├── news.py          ← SearXNG search + caching
+│       ├── tts.py           ← 8 TTS providers (cloud + local)
+│       └── transcription.py ← Whisper speech-to-text
+├── frontend/
+│   ├── index.html           ← Control panel layout
+│   ├── js/app.js            ← UI logic, polling, event handlers
+│   └── css/style.css        ← Dark theme styling
+├── sounds/                  ← SFX files (ring, hangup, busy, etc.)
+├── music/                   ← Background music tracks
+├── ads/                     ← Ad audio files
+├── website/                 ← Landing page (lukeattheroost.com)
+├── publish_episode.py       ← Castopod episode publisher
+└── run.sh                   ← Server launcher with restart support
+```

docs/plans/2026-02-05-real-callers-design.md

@@ -0,0 +1,189 @@
+# Real Callers + AI Follow-Up Design
+
+## Overview
+
+Add real phone callers to the AI Radio Show via Twilio, alongside existing AI callers. Real callers dial a phone number, wait in a hold queue, and get taken on air by the host. Three-way conversations between host, real caller, and AI caller are supported. AI follow-up callers automatically reference what real callers said.
+
+## Requirements
+
+- Real callers connect via Twilio phone number
+- Full-duplex audio — host and caller talk simultaneously, talk over each other
+- Each real caller gets their own dedicated audio channel for recording
+- Three-way calls: host + real caller + AI caller all live at once
+- AI caller can respond manually (host-triggered) or automatically (listens and decides when to jump in)
+- AI follow-up callers reference real caller conversations via show history
+- Auto follow-up mode: system picks an AI caller and connects them after a real call
+- Simple hold queue — callers wait with hold music, host sees list and picks who goes on air
+- Twilio webhooks exposed via Cloudflare tunnel
+
+## Architecture
+
+### Audio Routing (Loopback Channels)
+
+```
+Ch 1:  Host mic (existing)
+Ch 2:  AI callers / TTS (existing)
+Ch 3+: Real callers (dynamically assigned per call)
+Ch N-1: Music (existing)
+Ch N:   SFX (existing)
+```
+
+### Call Flow — Real Caller
+
+```
+Caller dials Twilio number
+  → Twilio POST /api/twilio/voice
+  → TwiML response: greeting + enqueue with hold music
+  → Caller waits in hold queue
+  → Host sees caller in dashboard queue panel
+  → Host clicks "Take Call"
+  → POST /api/queue/take/{call_sid}
+  → Twilio opens WebSocket to /api/twilio/stream
+  → Bidirectional audio:
+      Caller audio → decode mulaw → dedicated Loopback channel
+      Host audio + AI TTS → encode mulaw → Twilio → caller hears both
+  → Real-time Whisper transcription of caller audio
+  → Host hangs up → call summarized → stored in show history
+```
+
+### Three-Way Call Flow
+
+```
+Host mic ──────→ Ch 1 (recording)
+               → Twilio outbound (real caller hears you)
+               → Whisper transcription (AI gets your words)
+
+Real caller ──→ Ch 3+ (recording, dedicated channel)
+               → Whisper transcription (AI gets their words)
+               → Host headphones
+
+AI TTS ───────→ Ch 2 (recording)
+               → Twilio outbound (real caller hears AI)
+               → Host headphones (already works)
+```
+
+Conversation history becomes three-party with role labels: `host`, `real_caller`, `ai_caller`.
+
+### AI Auto-Respond Mode
+
+When toggled on, after each real caller transcription chunk:
+
+1. Lightweight LLM call ("should I respond?" — use fast model like Haiku)
+2. If YES → full response generated → TTS → plays on AI channel + streams to Twilio
+3. Cooldown (~10s) prevents rapid-fire
+4. Host can override with mute button
+
+### AI Follow-Up System
+
+After a real caller hangs up:
+
+1. Full transcript (host + real caller + any AI) summarized by LLM
+2. Summary stored in `session.call_history`
+3. Next AI caller's system prompt includes show history:
+   ```
+   EARLIER IN THE SHOW:
+   - Dave (real caller) called about his wife leaving after 12 years.
+     He got emotional about his kids.
+   - Jasmine called about her boss hitting on her at work.
+   You can reference these if it feels natural. Don't force it.
+   ```
+
+**Host-triggered (default):** Click any AI caller as normal. They already have show context.
+
+**Auto mode:** After real caller hangs up, system waits ~5-10s, picks a fitting AI caller via short LLM call, biases their background generation toward the topic, auto-connects.
+
+## Backend Changes
+
+### New Module: `backend/services/twilio_service.py`
+
+Manages Twilio integration:
+- WebSocket handler for Media Streams (decode/encode mulaw 8kHz ↔ PCM)
+- Call queue state (waiting callers, SIDs, timestamps, assigned channels)
+- Channel pool management (allocate/release Loopback channels for real callers)
+- Outbound audio mixing (host + AI TTS → mulaw → Twilio)
+- Methods: `take_call()`, `hangup_real_caller()`, `get_queue()`, `send_audio_to_caller()`
+
+### New Endpoints
+
+```python
+# Twilio webhooks
+POST /api/twilio/voice            # Incoming call → TwiML (greet + enqueue)
+POST /api/twilio/hold-music       # Hold music TwiML for waiting callers
+WS   /api/twilio/stream           # Media Streams WebSocket (bidirectional audio)
+
+# Host controls
+GET  /api/queue                    # List waiting callers (number, wait time)
+POST /api/queue/take/{call_sid}    # Dequeue caller → start media stream
+POST /api/queue/drop/{call_sid}    # Drop caller from queue
+
+# AI follow-up
+POST /api/followup/generate        # Summarize last real call, trigger AI follow-up
+```
+
+### Session Model Changes
+
+```python
+class CallRecord:
+    caller_type: str          # "ai" or "real"
+    caller_name: str          # "Tony" or "Caller #3"
+    summary: str              # LLM-generated summary after hangup
+    transcript: list[dict]    # Full conversation [{role, content}]
+
+class Session:
+    # Existing fields...
+    call_history: list[CallRecord]     # All calls this episode
+    active_real_caller: dict | None    # {call_sid, phone, channel, name}
+    active_ai_caller: str | None       # Caller key
+    ai_respond_mode: str               # "manual" or "auto"
+    auto_followup: bool                # Auto-generate AI follow-up after real calls
+```
+
+Three-party conversation history uses roles: `host`, `real_caller:{name}`, `ai_caller:{name}`.
+
+### AI Caller Prompt Changes
+
+`get_caller_prompt()` extended to include:
+- Show history from `session.call_history`
+- Current real caller context (if three-way call active)
+- Instructions for referencing real callers naturally
+
+## Frontend Changes
+
+### New: Call Queue Panel
+
+Between callers section and chat. Shows waiting real callers with phone number and wait time. "Take Call" and "Drop" buttons per caller. Polls `/api/queue` every few seconds.
+
+### Modified: Active Call Indicator
+
+Shows real caller and AI caller simultaneously when both active:
+- Real caller: name, channel number, call duration, hang up button
+- AI caller: name, Manual/Auto toggle, "Let [name] respond" button (manual mode)
+- Auto Follow-Up checkbox
+
+### Modified: Chat Log
+
+Three-party with visual distinction:
+- Host messages: existing style
+- Real caller: labeled "Dave (caller)", distinct color
+- AI caller: labeled "Tony (AI)", distinct color
+
+### Modified: Caller Grid
+
+When real caller is active, clicking an AI caller adds them as third party instead of starting fresh call. Indicator shows which AI callers have been on the show this session.
+
+## Dependencies
+
+- `twilio` Python package (for TwiML generation, REST API)
+- Twilio account with phone number (~$1.15/mo + per-minute)
+- Cloudflare tunnel for exposing webhook endpoints
+- `audioop` or equivalent for mulaw encode/decode (stdlib in Python 3.11)
+
+## Configuration
+
+New env vars in `.env`:
+```
+TWILIO_ACCOUNT_SID=...
+TWILIO_AUTH_TOKEN=...
+TWILIO_PHONE_NUMBER=+1...
+TWILIO_WEBHOOK_BASE_URL=https://your-tunnel.cloudflare.com
+```

docs/plans/2026-02-05-signalwire-callers-design.md

@@ -0,0 +1,52 @@
+# SignalWire Phone Call-In Design
+
+## Goal
+
+Replace browser-based WebSocket call-in with real phone calls via SignalWire. Callers dial 208-439-5853 and enter the show queue.
+
+## Architecture
+
+SignalWire handles PSTN connectivity. When a call comes in, SignalWire hits our webhook, we return XML telling it to open a bidirectional WebSocket stream with L16@16kHz audio. The audio flows through our existing pipeline — same queue, channel allocation, transcription, host mic streaming, and TTS streaming.
+
+## Call Flow
+
+1. Caller dials 208-439-5853
+2. SignalWire hits `POST /api/signalwire/voice` (via Cloudflare tunnel)
+3. We return `<Connect><Stream codec="L16@16000h">` XML
+4. SignalWire opens WebSocket to `/api/signalwire/stream`
+5. Caller enters queue — host sees phone number on dashboard
+6. Host takes call — audio flows bidirectionally
+7. Host hangs up — we call SignalWire REST API to end the phone call
+
+## Audio Path
+
+```
+Phone → PSTN → SignalWire → WebSocket (base64 L16 JSON) → Our server
+Our server → WebSocket (base64 L16 JSON) → SignalWire → PSTN → Phone
+```
+
+## SignalWire WebSocket Protocol
+
+Incoming: `{"event": "media", "media": {"payload": "<base64 L16 PCM 16kHz>"}}`
+Outgoing: `{"event": "media", "media": {"payload": "<base64 L16 PCM 16kHz>"}}`
+Start: `{"event": "start", "start": {"streamSid": "...", "callSid": "..."}}`
+Stop: `{"event": "stop"}`
+
+## What Changes
+
+- Remove: browser call-in page, browser WebSocket handler
+- Add: SignalWire webhook + WebSocket handler, hangup via REST API
+- Modify: CallerService (name→phone, base64 JSON encoding for send), dashboard (show phone number)
+- Unchanged: AudioService, queue logic, transcription, TTS streaming, three-way calls
+
+## Config
+
+```
+SIGNALWIRE_PROJECT_ID=8eb54732-ade3-4487-8b40-ecd2cd680df7
+SIGNALWIRE_SPACE=macneil-media-group-llc.signalwire.com
+SIGNALWIRE_TOKEN=PT9c9b61f44ee49914c614fed32aa5c3d7b9372b5199d81dec
+SIGNALWIRE_PHONE=+12084395853
+```
+
+Webhook URL: `https://radioshow.macneilmediagroup.com/api/signalwire/voice`
+No SDK needed — httpx for the one REST call (hangup).

docs/plans/2026-02-05-signalwire-implementation.md

@@ -0,0 +1,855 @@
+# SignalWire Phone Call-In Implementation Plan
+
+> **For Claude:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task.
+
+**Goal:** Replace browser-based WebSocket call-in with real phone calls via SignalWire (208-439-5853).
+
+**Architecture:** SignalWire hits our webhook on inbound calls, we return XML to open a bidirectional WebSocket stream with L16@16kHz audio. The existing queue, channel allocation, transcription, host mic streaming, and TTS streaming are reused — only the WebSocket message format changes (base64 JSON instead of raw binary).
+
+**Tech Stack:** Python/FastAPI, SignalWire Compatibility API (LaML XML + WebSocket), httpx for REST calls, existing audio pipeline.
+
+---
+
+## Task 1: Add SignalWire Config
+
+**Files:**
+- Modify: `backend/config.py`
+- Modify: `.env`
+
+**Step 1: Add SignalWire settings to config.py**
+
+In `backend/config.py`, add these fields to the `Settings` class after the existing API keys block (after line 16):
+
+```python
+    # SignalWire
+    signalwire_project_id: str = os.getenv("SIGNALWIRE_PROJECT_ID", "")
+    signalwire_space: str = os.getenv("SIGNALWIRE_SPACE", "")
+    signalwire_token: str = os.getenv("SIGNALWIRE_TOKEN", "")
+    signalwire_phone: str = os.getenv("SIGNALWIRE_PHONE", "")
+```
+
+**Step 2: Add SignalWire vars to .env**
+
+Append to `.env`:
+
+```
+# SignalWire
+SIGNALWIRE_PROJECT_ID=8eb54732-ade3-4487-8b40-ecd2cd680df7
+SIGNALWIRE_SPACE=macneil-media-group-llc.signalwire.com
+SIGNALWIRE_TOKEN=PT9c9b61f44ee49914c614fed32aa5c3d7b9372b5199d81dec
+SIGNALWIRE_PHONE=+12084395853
+```
+
+**Step 3: Verify config loads**
+
+```bash
+cd /Users/lukemacneil/ai-podcast && python -c "from backend.config import settings; print(settings.signalwire_space)"
+```
+
+Expected: `macneil-media-group-llc.signalwire.com`
+
+**Step 4: Commit**
+
+```bash
+git add backend/config.py .env
+git commit -m "Add SignalWire configuration"
+```
+
+---
+
+## Task 2: Update CallerService for SignalWire Protocol
+
+**Files:**
+- Modify: `backend/services/caller_service.py`
+
+The CallerService currently sends raw binary PCM frames. SignalWire needs base64-encoded L16 PCM wrapped in JSON. Also swap `name` field to `phone` since callers now have phone numbers.
+
+**Step 1: Update queue to use `phone` instead of `name`**
+
+In `caller_service.py`, make these changes:
+
+1. Update docstring (line 1): `"""Phone caller queue and audio stream service"""`
+
+2. In `add_to_queue` (line 24): Change parameter `name` to `phone`, and update the dict:
+
+```python
+    def add_to_queue(self, caller_id: str, phone: str):
+        with self._lock:
+            self._queue.append({
+                "caller_id": caller_id,
+                "phone": phone,
+                "queued_at": time.time(),
+            })
+        print(f"[Caller] {phone} added to queue (ID: {caller_id})")
+```
+
+3. In `get_queue` (line 38): Return `phone` instead of `name`:
+
+```python
+    def get_queue(self) -> list[dict]:
+        now = time.time()
+        with self._lock:
+            return [
+                {
+                    "caller_id": c["caller_id"],
+                    "phone": c["phone"],
+                    "wait_time": int(now - c["queued_at"]),
+                }
+                for c in self._queue
+            ]
+```
+
+4. In `take_call` (line 62): Use `phone` instead of `name`:
+
+```python
+    def take_call(self, caller_id: str) -> dict:
+        caller = None
+        with self._lock:
+            for c in self._queue:
+                if c["caller_id"] == caller_id:
+                    caller = c
+                    break
+            if caller:
+                self._queue = [c for c in self._queue if c["caller_id"] != caller_id]
+
+        if not caller:
+            raise ValueError(f"Caller {caller_id} not in queue")
+
+        channel = self.allocate_channel()
+        self._caller_counter += 1
+        phone = caller["phone"]
+
+        call_info = {
+            "caller_id": caller_id,
+            "phone": phone,
+            "channel": channel,
+            "started_at": time.time(),
+        }
+        self.active_calls[caller_id] = call_info
+        print(f"[Caller] {phone} taken on air — channel {channel}")
+        return call_info
+```
+
+5. In `hangup` (line 89): Use `phone` instead of `name`:
+
+```python
+    def hangup(self, caller_id: str):
+        call_info = self.active_calls.pop(caller_id, None)
+        if call_info:
+            self.release_channel(call_info["channel"])
+            print(f"[Caller] {call_info['phone']} hung up — channel {call_info['channel']} released")
+        self._websockets.pop(caller_id, None)
+```
+
+**Step 2: Update `send_audio_to_caller` for SignalWire JSON format**
+
+Replace the existing `send_audio_to_caller` method with:
+
+```python
+    async def send_audio_to_caller(self, caller_id: str, pcm_data: bytes, sample_rate: int):
+        """Send small audio chunk to caller via SignalWire WebSocket.
+        Encodes L16 PCM as base64 JSON per SignalWire protocol.
+        """
+        ws = self._websockets.get(caller_id)
+        if not ws:
+            return
+
+        try:
+            import base64
+            if sample_rate != 16000:
+                audio = np.frombuffer(pcm_data, dtype=np.int16).astype(np.float32) / 32768.0
+                ratio = 16000 / sample_rate
+                out_len = int(len(audio) * ratio)
+                indices = (np.arange(out_len) / ratio).astype(int)
+                indices = np.clip(indices, 0, len(audio) - 1)
+                audio = audio[indices]
+                pcm_data = (audio * 32767).astype(np.int16).tobytes()
+
+            payload = base64.b64encode(pcm_data).decode('ascii')
+            import json
+            await ws.send_text(json.dumps({
+                "event": "media",
+                "media": {"payload": payload}
+            }))
+        except Exception as e:
+            print(f"[Caller] Failed to send audio: {e}")
+```
+
+**Step 3: Update `stream_audio_to_caller` for SignalWire JSON format**
+
+Replace the existing `stream_audio_to_caller` method with:
+
+```python
+    async def stream_audio_to_caller(self, caller_id: str, pcm_data: bytes, sample_rate: int):
+        """Stream large audio (TTS) to caller in real-time chunks via SignalWire WebSocket."""
+        ws = self._websockets.get(caller_id)
+        if not ws:
+            return
+
+        self.streaming_tts = True
+        try:
+            import base64
+            import json
+            audio = np.frombuffer(pcm_data, dtype=np.int16).astype(np.float32) / 32768.0
+            if sample_rate != 16000:
+                ratio = 16000 / sample_rate
+                out_len = int(len(audio) * ratio)
+                indices = (np.arange(out_len) / ratio).astype(int)
+                indices = np.clip(indices, 0, len(audio) - 1)
+                audio = audio[indices]
+
+            chunk_samples = 960
+            for i in range(0, len(audio), chunk_samples):
+                if caller_id not in self._websockets:
+                    break
+                chunk = audio[i:i + chunk_samples]
+                pcm_chunk = (chunk * 32767).astype(np.int16).tobytes()
+                payload = base64.b64encode(pcm_chunk).decode('ascii')
+                await ws.send_text(json.dumps({
+                    "event": "media",
+                    "media": {"payload": payload}
+                }))
+                await asyncio.sleep(0.055)
+
+        except Exception as e:
+            print(f"[Caller] Failed to stream audio: {e}")
+        finally:
+            self.streaming_tts = False
+```
+
+**Step 4: Remove `notify_caller` and `disconnect_caller` methods**
+
+These sent browser-specific JSON control messages. SignalWire callers are disconnected via REST API (handled in main.py). Delete methods `notify_caller` (line 168) and `disconnect_caller` (line 175). They will be replaced with a REST-based hangup in Task 4.
+
+**Step 5: Add `call_sid` tracking for SignalWire call hangup**
+
+Add a dict to track SignalWire call SIDs so we can end calls via REST:
+
+In `__init__`, after `self._websockets` line, add:
+
+```python
+        self._call_sids: dict[str, str] = {}  # caller_id -> SignalWire callSid
+```
+
+Add methods:
+
+```python
+    def register_call_sid(self, caller_id: str, call_sid: str):
+        """Track SignalWire callSid for a caller"""
+        self._call_sids[caller_id] = call_sid
+
+    def get_call_sid(self, caller_id: str) -> str | None:
+        """Get SignalWire callSid for a caller"""
+        return self._call_sids.get(caller_id)
+
+    def unregister_call_sid(self, caller_id: str):
+        """Remove callSid tracking"""
+        self._call_sids.pop(caller_id, None)
+```
+
+In `reset`, also clear `self._call_sids`:
+
+```python
+            self._call_sids.clear()
+```
+
+In `hangup`, also clean up call_sid:
+
+```python
+        self._call_sids.pop(caller_id, None)
+```
+
+**Step 6: Run existing tests**
+
+```bash
+cd /Users/lukemacneil/ai-podcast && python -m pytest tests/test_caller_service.py -v
+```
+
+Tests will likely need updates due to `name` → `phone` rename. Fix any failures.
+
+**Step 7: Commit**
+
+```bash
+git add backend/services/caller_service.py
+git commit -m "Update CallerService for SignalWire protocol"
+```
+
+---
+
+## Task 3: Add SignalWire Voice Webhook
+
+**Files:**
+- Modify: `backend/main.py`
+
+**Step 1: Add the voice webhook endpoint**
+
+Add after the existing route definitions (after line 421), replacing the `/call-in` route:
+
+```python
+# --- SignalWire Endpoints ---
+
+from fastapi import Request, Response
+
+@app.post("/api/signalwire/voice")
+async def signalwire_voice_webhook(request: Request):
+    """Handle inbound call from SignalWire — return XML to start bidirectional stream"""
+    form = await request.form()
+    caller_phone = form.get("From", "Unknown")
+    call_sid = form.get("CallSid", "")
+    print(f"[SignalWire] Inbound call from {caller_phone} (CallSid: {call_sid})")
+
+    # Build WebSocket URL from the request
+    ws_scheme = "wss"
+    host = request.headers.get("host", "radioshow.macneilmediagroup.com")
+    stream_url = f"{ws_scheme}://{host}/api/signalwire/stream"
+
+    xml = f"""<?xml version="1.0" encoding="UTF-8"?>
+<Response>
+    <Connect>
+        <Stream url="{stream_url}" codec="L16@16000h">
+            <Parameter name="caller_phone" value="{caller_phone}"/>
+            <Parameter name="call_sid" value="{call_sid}"/>
+        </Stream>
+    </Connect>
+</Response>"""
+
+    return Response(content=xml, media_type="application/xml")
+```
+
+**Step 2: Remove the `/call-in` route**
+
+Delete these lines (around line 419-421):
+
+```python
+@app.get("/call-in")
+async def call_in_page():
+    return FileResponse(frontend_dir / "call-in.html")
+```
+
+**Step 3: Verify server starts**
+
+```bash
+cd /Users/lukemacneil/ai-podcast && python -c "from backend.main import app; print('OK')"
+```
+
+**Step 4: Commit**
+
+```bash
+git add backend/main.py
+git commit -m "Add SignalWire voice webhook, remove call-in route"
+```
+
+---
+
+## Task 4: Add SignalWire WebSocket Stream Handler
+
+**Files:**
+- Modify: `backend/main.py`
+
+This replaces the browser caller WebSocket handler at `/api/caller/stream`.
+
+**Step 1: Replace the browser WebSocket handler**
+
+Delete the entire `caller_audio_stream` function (the `@app.websocket("/api/caller/stream")` handler, lines 807-887).
+
+Add the new SignalWire WebSocket handler:
+
+```python
+@app.websocket("/api/signalwire/stream")
+async def signalwire_audio_stream(websocket: WebSocket):
+    """Handle SignalWire bidirectional audio stream"""
+    await websocket.accept()
+
+    caller_id = str(uuid.uuid4())[:8]
+    caller_phone = "Unknown"
+    call_sid = ""
+    audio_buffer = bytearray()
+    CHUNK_DURATION_S = 3
+    SAMPLE_RATE = 16000
+    chunk_samples = CHUNK_DURATION_S * SAMPLE_RATE
+    stream_started = False
+
+    try:
+        while True:
+            raw = await websocket.receive_text()
+            msg = json.loads(raw)
+            event = msg.get("event")
+
+            if event == "start":
+                # Extract caller info from stream parameters
+                params = {}
+                for p in msg.get("start", {}).get("customParameters", {}):
+                    pass
+                # customParameters comes as a dict
+                custom = msg.get("start", {}).get("customParameters", {})
+                caller_phone = custom.get("caller_phone", "Unknown")
+                call_sid = custom.get("call_sid", "")
+
+                stream_started = True
+                print(f"[SignalWire WS] Stream started: {caller_phone} (CallSid: {call_sid})")
+
+                # Add to queue and register
+                caller_service.add_to_queue(caller_id, caller_phone)
+                caller_service.register_websocket(caller_id, websocket)
+                if call_sid:
+                    caller_service.register_call_sid(caller_id, call_sid)
+
+            elif event == "media" and stream_started:
+                # Decode base64 L16 PCM audio
+                import base64
+                payload = msg.get("media", {}).get("payload", "")
+                if not payload:
+                    continue
+
+                pcm_data = base64.b64decode(payload)
+
+                # Only process audio if caller is on air
+                call_info = caller_service.active_calls.get(caller_id)
+                if not call_info:
+                    continue
+
+                audio_buffer.extend(pcm_data)
+
+                # Route to configured live caller Loopback channel
+                audio_service.route_real_caller_audio(pcm_data, SAMPLE_RATE)
+
+                # Transcribe when we have enough audio
+                if len(audio_buffer) >= chunk_samples * 2:
+                    pcm_chunk = bytes(audio_buffer[:chunk_samples * 2])
+                    audio_buffer = audio_buffer[chunk_samples * 2:]
+                    asyncio.create_task(
+                        _handle_real_caller_transcription(caller_id, pcm_chunk, SAMPLE_RATE)
+                    )
+
+            elif event == "stop":
+                print(f"[SignalWire WS] Stream stopped: {caller_phone}")
+                break
+
+    except WebSocketDisconnect:
+        print(f"[SignalWire WS] Disconnected: {caller_id} ({caller_phone})")
+    except Exception as e:
+        print(f"[SignalWire WS] Error: {e}")
+    finally:
+        caller_service.unregister_websocket(caller_id)
+        caller_service.unregister_call_sid(caller_id)
+        caller_service.remove_from_queue(caller_id)
+        if caller_id in caller_service.active_calls:
+            caller_service.hangup(caller_id)
+            if session.active_real_caller and session.active_real_caller.get("caller_id") == caller_id:
+                session.active_real_caller = None
+                if len(caller_service.active_calls) == 0:
+                    audio_service.stop_host_stream()
+        if audio_buffer:
+            asyncio.create_task(
+                _handle_real_caller_transcription(caller_id, bytes(audio_buffer), SAMPLE_RATE)
+            )
+```
+
+**Step 2: Commit**
+
+```bash
+git add backend/main.py
+git commit -m "Add SignalWire WebSocket stream handler, remove browser handler"
+```
+
+---
+
+## Task 5: Update Hangup and Queue Endpoints for SignalWire
+
+**Files:**
+- Modify: `backend/main.py`
+
+When the host hangs up or drops a caller, we need to end the actual phone call via SignalWire's REST API.
+
+**Step 1: Add SignalWire hangup helper**
+
+Add this function near the top of `main.py` (after imports):
+
+```python
+async def _signalwire_end_call(call_sid: str):
+    """End a phone call via SignalWire REST API"""
+    if not call_sid or not settings.signalwire_space:
+        return
+    try:
+        url = f"https://{settings.signalwire_space}/api/laml/2010-04-01/Accounts/{settings.signalwire_project_id}/Calls/{call_sid}"
+        async with httpx.AsyncClient(timeout=10.0) as client:
+            response = await client.post(
+                url,
+                data={"Status": "completed"},
+                auth=(settings.signalwire_project_id, settings.signalwire_token),
+            )
+            print(f"[SignalWire] End call {call_sid}: {response.status_code}")
+    except Exception as e:
+        print(f"[SignalWire] Failed to end call {call_sid}: {e}")
+```
+
+Also add `import httpx` at the top of main.py if not already present.
+
+**Step 2: Update `take_call_from_queue`**
+
+In the `take_call_from_queue` endpoint, update `name` references to `phone`:
+
+```python
+@app.post("/api/queue/take/{caller_id}")
+async def take_call_from_queue(caller_id: str):
+    """Take a caller off hold and put them on air"""
+    try:
+        call_info = caller_service.take_call(caller_id)
+    except ValueError as e:
+        raise HTTPException(404, str(e))
+
+    session.active_real_caller = {
+        "caller_id": call_info["caller_id"],
+        "channel": call_info["channel"],
+        "phone": call_info["phone"],
+    }
+
+    # Start host mic streaming if this is the first real caller
+    if len(caller_service.active_calls) == 1:
+        _start_host_audio_sender()
+        audio_service.start_host_stream(_host_audio_sync_callback)
+
+    return {
+        "status": "on_air",
+        "caller": call_info,
+    }
+```
+
+Note: The `notify_caller` call is removed — SignalWire callers don't need a JSON status message, they're already connected via the phone.
+
+**Step 3: Update `drop_from_queue`**
+
+End the phone call when dropping:
+
+```python
+@app.post("/api/queue/drop/{caller_id}")
+async def drop_from_queue(caller_id: str):
+    """Drop a caller from the queue"""
+    call_sid = caller_service.get_call_sid(caller_id)
+    caller_service.remove_from_queue(caller_id)
+    if call_sid:
+        await _signalwire_end_call(call_sid)
+    return {"status": "dropped"}
+```
+
+**Step 4: Update `hangup_real_caller`**
+
+End the phone call when hanging up:
+
+```python
+@app.post("/api/hangup/real")
+async def hangup_real_caller():
+    """Hang up on real caller — disconnect immediately, summarize in background"""
+    if not session.active_real_caller:
+        raise HTTPException(400, "No active real caller")
+
+    caller_id = session.active_real_caller["caller_id"]
+    caller_phone = session.active_real_caller["phone"]
+    conversation_snapshot = list(session.conversation)
+    auto_followup_enabled = session.auto_followup
+
+    # End the phone call via SignalWire
+    call_sid = caller_service.get_call_sid(caller_id)
+    caller_service.hangup(caller_id)
+    if call_sid:
+        asyncio.create_task(_signalwire_end_call(call_sid))
+
+    # Stop host streaming if no more active callers
+    if len(caller_service.active_calls) == 0:
+        audio_service.stop_host_stream()
+
+    session.active_real_caller = None
+
+    # Play hangup sound in background
+    import threading
+    hangup_sound = settings.sounds_dir / "hangup.wav"
+    if hangup_sound.exists():
+        threading.Thread(target=audio_service.play_sfx, args=(str(hangup_sound),), daemon=True).start()
+
+    # Summarize and store history in background
+    asyncio.create_task(
+        _summarize_real_call(caller_phone, conversation_snapshot, auto_followup_enabled)
+    )
+
+    return {
+        "status": "disconnected",
+        "caller": caller_phone,
+    }
+```
+
+**Step 5: Update `_handle_real_caller_transcription`**
+
+Change `caller_name` to `caller_phone`:
+
+```python
+async def _handle_real_caller_transcription(caller_id: str, pcm_data: bytes, sample_rate: int):
+    """Transcribe a chunk of real caller audio and add to conversation"""
+    call_info = caller_service.active_calls.get(caller_id)
+    if not call_info:
+        return
+
+    text = await transcribe_audio(pcm_data, source_sample_rate=sample_rate)
+    if not text or not text.strip():
+        return
+
+    caller_phone = call_info["phone"]
+    print(f"[Real Caller] {caller_phone}: {text}")
+
+    session.add_message(f"real_caller:{caller_phone}", text)
+
+    if session.ai_respond_mode == "auto" and session.current_caller_key:
+        asyncio.create_task(_check_ai_auto_respond(text, caller_phone))
+```
+
+**Step 6: Update `_summarize_real_call`**
+
+Change `caller_name` parameter to `caller_phone`:
+
+```python
+async def _summarize_real_call(caller_phone: str, conversation: list, auto_followup_enabled: bool):
+    """Background task: summarize call and store in history"""
+    summary = ""
+    if conversation:
+        transcript_text = "\n".join(
+            f"{msg['role']}: {msg['content']}" for msg in conversation
+        )
+        summary = await llm_service.generate(
+            messages=[{"role": "user", "content": f"Summarize this radio show call in 1-2 sentences:\n{transcript_text}"}],
+            system_prompt="You summarize radio show conversations concisely. Focus on what the caller talked about and any emotional moments.",
+        )
+
+    session.call_history.append(CallRecord(
+        caller_type="real",
+        caller_name=caller_phone,
+        summary=summary,
+        transcript=conversation,
+    ))
+    print(f"[Real Caller] {caller_phone} call summarized: {summary[:80]}...")
+
+    if auto_followup_enabled:
+        await _auto_followup(summary)
+```
+
+**Step 7: Update `_check_ai_auto_respond`**
+
+Change parameter name from `real_caller_name` to `real_caller_phone`:
+
+```python
+async def _check_ai_auto_respond(real_caller_text: str, real_caller_phone: str):
+```
+
+(The body doesn't use the name/phone parameter in any way that needs changing.)
+
+**Step 8: Update TTS streaming references**
+
+In `text_to_speech` endpoint and `_check_ai_auto_respond`, the `session.active_real_caller` dict now uses `phone` instead of `name`. No code change needed for the TTS streaming since it only uses `caller_id`.
+
+**Step 9: Verify server starts**
+
+```bash
+cd /Users/lukemacneil/ai-podcast && python -c "from backend.main import app; print('OK')"
+```
+
+**Step 10: Commit**
+
+```bash
+git add backend/main.py
+git commit -m "Update hangup and queue endpoints for SignalWire REST API"
+```
+
+---
+
+## Task 6: Update Frontend for Phone Callers
+
+**Files:**
+- Modify: `frontend/js/app.js`
+- Modify: `frontend/index.html`
+
+**Step 1: Update queue rendering in app.js**
+
+In `renderQueue` function (around line 875), change `caller.name` to `caller.phone`:
+
+```javascript
+    el.innerHTML = queue.map(caller => {
+        const mins = Math.floor(caller.wait_time / 60);
+        const secs = caller.wait_time % 60;
+        const waitStr = mins > 0 ? `${mins}m ${secs}s` : `${secs}s`;
+        return `
+            <div class="queue-item">
+                <span class="queue-name">${caller.phone}</span>
+                <span class="queue-wait">waiting ${waitStr}</span>
+                <button class="queue-take-btn" onclick="takeCall('${caller.caller_id}')">Take Call</button>
+                <button class="queue-drop-btn" onclick="dropCall('${caller.caller_id}')">Drop</button>
+            </div>
+        `;
+    }).join('');
+```
+
+**Step 2: Update `takeCall` log message**
+
+In `takeCall` function (around line 896), change `data.caller.name` to `data.caller.phone`:
+
+```javascript
+        if (data.status === 'on_air') {
+            showRealCaller(data.caller);
+            log(`${data.caller.phone} is on air — Channel ${data.caller.channel}`);
+        }
+```
+
+**Step 3: Update `showRealCaller` to use phone**
+
+In `showRealCaller` function (around line 939):
+
+```javascript
+function showRealCaller(callerInfo) {
+    const nameEl = document.getElementById('real-caller-name');
+    const chEl = document.getElementById('real-caller-channel');
+    if (nameEl) nameEl.textContent = callerInfo.phone;
+    if (chEl) chEl.textContent = `Ch ${callerInfo.channel}`;
+```
+
+**Step 4: Update index.html queue section header**
+
+In `frontend/index.html`, change the queue section header (line 56) — remove the call-in page link:
+
+```html
+            <section class="queue-section">
+                <h2>Incoming Calls</h2>
+                <div id="call-queue" class="call-queue">
+```
+
+**Step 5: Bump cache version in index.html**
+
+Find the app.js script tag and bump the version:
+
+```html
+<script src="/js/app.js?v=13"></script>
+```
+
+**Step 6: Commit**
+
+```bash
+git add frontend/js/app.js frontend/index.html
+git commit -m "Update frontend for phone caller display"
+```
+
+---
+
+## Task 7: Remove Browser Call-In Files
+
+**Files:**
+- Delete: `frontend/call-in.html`
+- Delete: `frontend/js/call-in.js`
+
+**Step 1: Delete files**
+
+```bash
+cd /Users/lukemacneil/ai-podcast && rm frontend/call-in.html frontend/js/call-in.js
+```
+
+**Step 2: Commit**
+
+```bash
+git add frontend/call-in.html frontend/js/call-in.js
+git commit -m "Remove browser call-in page"
+```
+
+---
+
+## Task 8: Update Tests
+
+**Files:**
+- Modify: `tests/test_caller_service.py`
+
+**Step 1: Update tests for `name` → `phone` rename**
+
+Throughout `test_caller_service.py`, change:
+- `add_to_queue(caller_id, "TestName")` → `add_to_queue(caller_id, "+15551234567")`
+- `caller["name"]` → `caller["phone"]`
+- `call_info["name"]` → `call_info["phone"]`
+
+Also remove any tests for `notify_caller` or `disconnect_caller` if they exist, since those methods were removed.
+
+**Step 2: Run all tests**
+
+```bash
+cd /Users/lukemacneil/ai-podcast && python -m pytest tests/ -v
+```
+
+Expected: All pass.
+
+**Step 3: Commit**
+
+```bash
+git add tests/
+git commit -m "Update tests for SignalWire phone caller format"
+```
+
+---
+
+## Task 9: Configure SignalWire Webhook and End-to-End Test
+
+**Step 1: Start the server**
+
+```bash
+cd /Users/lukemacneil/ai-podcast && python -m uvicorn backend.main:app --reload --host 0.0.0.0 --port 8000
+```
+
+**Step 2: Verify webhook endpoint responds**
+
+```bash
+curl -X POST http://localhost:8000/api/signalwire/voice \
+  -d "From=+15551234567&CallSid=test123" \
+  -H "Content-Type: application/x-www-form-urlencoded"
+```
+
+Expected: XML response with `<Connect><Stream>` containing the WebSocket URL.
+
+**Step 3: Verify Cloudflare tunnel is running**
+
+```bash
+curl -s https://radioshow.macneilmediagroup.com/api/server/status
+```
+
+Expected: JSON response with `"status": "running"`.
+
+**Step 4: Configure SignalWire webhook**
+
+In the SignalWire dashboard:
+1. Go to Phone Numbers → 208-439-5853
+2. Set "When a call comes in" to: `https://radioshow.macneilmediagroup.com/api/signalwire/voice`
+3. Method: POST
+4. Handler type: LaML Webhooks
+
+**Step 5: Test with a real call**
+
+Call 208-439-5853 from a phone. Expected:
+1. Call connects (no ringing/hold — goes straight to stream)
+2. Caller appears in queue on host dashboard with phone number
+3. Host clicks "Take Call" → audio flows bidirectionally
+4. Host clicks "Hang Up" → phone call ends
+
+**Step 6: Commit any fixes needed**
+
+```bash
+git add -A
+git commit -m "Final SignalWire integration fixes"
+```
+
+---
+
+## Summary
+
+| Task | What | Key Files |
+|------|------|-----------|
+| 1 | SignalWire config | `config.py`, `.env` |
+| 2 | CallerService protocol update | `caller_service.py` |
+| 3 | Voice webhook endpoint | `main.py` |
+| 4 | WebSocket stream handler | `main.py` |
+| 5 | Hangup/queue via REST API | `main.py` |
+| 6 | Frontend phone display | `app.js`, `index.html` |
+| 7 | Remove browser call-in | `call-in.html`, `call-in.js` |
+| 8 | Update tests | `tests/` |
+| 9 | Configure & test | SignalWire dashboard |
+
+Tasks 1-5 are sequential backend. Task 6-7 are frontend (can parallel after task 5). Task 8 after task 2. Task 9 is final integration test.

docs/plans/2026-02-15-clip-social-upload.md

@@ -0,0 +1,505 @@
+# Clip Social Media Upload Implementation Plan
+
+> **For Claude:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task.
+
+**Goal:** Generate social media descriptions/hashtags for podcast clips and upload them to Instagram Reels + YouTube Shorts via Postiz API.
+
+**Architecture:** Two changes — (1) extend `make_clips.py` to add a second LLM call that generates descriptions + hashtags, saved as `clips-metadata.json`, (2) new `upload_clips.py` script that reads that metadata and pushes clips through the self-hosted Postiz instance at `social.lukeattheroost.com`.
+
+**Tech Stack:** Python, OpenRouter API (Claude Sonnet), Postiz REST API, requests library (already installed)
+
+---
+
+### Task 1: Add `generate_social_metadata()` to `make_clips.py`
+
+**Files:**
+- Modify: `make_clips.py:231-312` (after `select_clips_with_llm`)
+
+**Step 1: Add the function after `select_clips_with_llm`**
+
+Add this function at line ~314 (after `select_clips_with_llm` returns):
+
+```python
+def generate_social_metadata(clips: list[dict], labeled_transcript: str,
+                              episode_number: int | None) -> list[dict]:
+    """Generate social media descriptions and hashtags for each clip."""
+    if not OPENROUTER_API_KEY:
+        print("Error: OPENROUTER_API_KEY not set in .env")
+        sys.exit(1)
+
+    clips_summary = "\n".join(
+        f'{i+1}. "{c["title"]}" — {c["caption_text"]}'
+        for i, c in enumerate(clips)
+    )
+
+    episode_context = f"This is Episode {episode_number} of " if episode_number else "This is an episode of "
+
+    prompt = f"""{episode_context}the "Luke at the Roost" podcast — a late-night call-in show where AI-generated callers share stories, confessions, and hot takes with host Luke.
+
+Here are {len(clips)} clips selected from this episode:
+
+{clips_summary}
+
+For each clip, generate:
+1. description: A short, engaging description for social media (1-2 sentences, hook the viewer, conversational tone). Do NOT include hashtags in the description.
+2. hashtags: An array of 5-8 hashtags. Always include #lukeattheroost and #podcast. Add topic-relevant and trending-style tags.
+
+Respond with ONLY a JSON array matching the clip order:
+[{{"description": "...", "hashtags": ["#tag1", "#tag2", ...]}}]"""
+
+    response = requests.post(
+        "https://openrouter.ai/api/v1/chat/completions",
+        headers={
+            "Authorization": f"Bearer {OPENROUTER_API_KEY}",
+            "Content-Type": "application/json",
+        },
+        json={
+            "model": "anthropic/claude-sonnet-4-5",
+            "messages": [{"role": "user", "content": prompt}],
+            "max_tokens": 2048,
+            "temperature": 0.7,
+        },
+    )
+
+    if response.status_code != 200:
+        print(f"Error from OpenRouter: {response.text}")
+        return clips
+
+    content = response.json()["choices"][0]["message"]["content"].strip()
+    if content.startswith("```"):
+        content = re.sub(r"^```(?:json)?\n?", "", content)
+        content = re.sub(r"\n?```$", "", content)
+
+    try:
+        metadata = json.loads(content)
+    except json.JSONDecodeError as e:
+        print(f"Error parsing social metadata: {e}")
+        return clips
+
+    for i, clip in enumerate(clips):
+        if i < len(metadata):
+            clip["description"] = metadata[i].get("description", "")
+            clip["hashtags"] = metadata[i].get("hashtags", [])
+
+    return clips
+```
+
+**Step 2: Run existing tests to verify no breakage**
+
+Run: `pytest tests/ -v`
+Expected: All existing tests pass (this is a new function, no side effects yet)
+
+**Step 3: Commit**
+
+```bash
+git add make_clips.py
+git commit -m "Add generate_social_metadata() for clip descriptions and hashtags"
+```
+
+---
+
+### Task 2: Integrate metadata generation + JSON save into `main()`
+
+**Files:**
+- Modify: `make_clips.py:1082-1289` (inside `main()`)
+
+**Step 1: Add metadata generation call and JSON save**
+
+After the LLM clip selection step (~line 1196, after the clip summary print loop), add:
+
+```python
+    # Step N: Generate social media metadata
+    print(f"\n[{extract_step - 1}/{step_total}] Generating social media descriptions...")
+    clips = generate_social_metadata(clips, labeled_transcript, episode_number)
+    for i, clip in enumerate(clips):
+        if "description" in clip:
+            print(f"    Clip {i+1}: {clip['description'][:80]}...")
+            print(f"           {' '.join(clip.get('hashtags', []))}")
+```
+
+Note: This needs to be inserted BEFORE the audio extraction step, and the step numbering needs to be adjusted (total steps goes from 5/6 to 6/7).
+
+At the end of `main()`, before the summary print, save the metadata JSON:
+
+```python
+    # Save clips metadata for social upload
+    metadata_path = output_dir / "clips-metadata.json"
+    metadata = []
+    for i, clip in enumerate(clips):
+        slug = slugify(clip["title"])
+        metadata.append({
+            "title": clip["title"],
+            "clip_file": f"clip-{i+1}-{slug}.mp4",
+            "audio_file": f"clip-{i+1}-{slug}.mp3",
+            "caption_text": clip.get("caption_text", ""),
+            "description": clip.get("description", ""),
+            "hashtags": clip.get("hashtags", []),
+            "start_time": clip["start_time"],
+            "end_time": clip["end_time"],
+            "duration": round(clip["end_time"] - clip["start_time"], 1),
+            "episode_number": episode_number,
+        })
+    with open(metadata_path, "w") as f:
+        json.dump(metadata, f, indent=2)
+    print(f"\nSocial metadata: {metadata_path}")
+```
+
+**Step 2: Adjust step numbering**
+
+The pipeline steps need to account for the new metadata step. Update `step_total` calculation:
+
+```python
+    step_total = (7 if two_pass else 6)
+```
+
+And shift the extract/video step numbers up by 1.
+
+**Step 3: Test manually**
+
+Run: `python make_clips.py --help`
+Expected: No import errors, help displays normally
+
+**Step 4: Commit**
+
+```bash
+git add make_clips.py
+git commit -m "Save clips-metadata.json with social descriptions and hashtags"
+```
+
+---
+
+### Task 3: Create `upload_clips.py` — core structure and Postiz API helpers
+
+**Files:**
+- Create: `upload_clips.py`
+
+**Step 1: Write the script**
+
+```python
+#!/usr/bin/env python3
+"""Upload podcast clips to Instagram Reels and YouTube Shorts via Postiz.
+
+Usage:
+    python upload_clips.py clips/episode-12/
+    python upload_clips.py clips/episode-12/ --clip 1
+    python upload_clips.py clips/episode-12/ --youtube-only
+    python upload_clips.py clips/episode-12/ --instagram-only
+    python upload_clips.py clips/episode-12/ --schedule "2026-02-16T10:00:00"
+    python upload_clips.py clips/episode-12/ --yes  # skip confirmation
+"""
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+import requests
+from dotenv import load_dotenv
+import os
+
+load_dotenv(Path(__file__).parent / ".env")
+
+POSTIZ_API_KEY = os.getenv("POSTIZ_API_KEY")
+POSTIZ_URL = os.getenv("POSTIZ_URL", "https://social.lukeattheroost.com")
+
+
+def get_api_url(path: str) -> str:
+    """Build full Postiz API URL."""
+    base = POSTIZ_URL.rstrip("/")
+    # Postiz self-hosted API is at /api/public/v1 when NEXT_PUBLIC_BACKEND_URL is the app URL
+    # but the docs say /public/v1 relative to backend URL. Try the standard path.
+    return f"{base}/api/public/v1{path}"
+
+
+def api_headers() -> dict:
+    return {
+        "Authorization": POSTIZ_API_KEY,
+        "Content-Type": "application/json",
+    }
+
+
+def fetch_integrations() -> list[dict]:
+    """Fetch connected social accounts from Postiz."""
+    resp = requests.get(get_api_url("/integrations"), headers=api_headers(), timeout=15)
+    if resp.status_code != 200:
+        print(f"Error fetching integrations: {resp.status_code} {resp.text[:200]}")
+        sys.exit(1)
+    return resp.json()
+
+
+def find_integration(integrations: list[dict], provider: str) -> dict | None:
+    """Find integration by provider name (e.g. 'instagram', 'youtube')."""
+    for integ in integrations:
+        if integ.get("providerIdentifier", "").startswith(provider):
+            return integ
+        if integ.get("provider", "").startswith(provider):
+            return integ
+    return None
+
+
+def upload_file(file_path: Path) -> dict:
+    """Upload a file to Postiz. Returns {id, path}."""
+    headers = {"Authorization": POSTIZ_API_KEY}
+    with open(file_path, "rb") as f:
+        resp = requests.post(
+            get_api_url("/upload"),
+            headers=headers,
+            files={"file": (file_path.name, f, "video/mp4")},
+            timeout=120,
+        )
+    if resp.status_code != 200:
+        print(f"Upload failed: {resp.status_code} {resp.text[:200]}")
+        return {}
+    return resp.json()
+
+
+def create_post(integration_id: str, content: str, media: dict,
+                settings: dict, schedule: str | None = None) -> dict:
+    """Create a post on Postiz."""
+    post_type = "schedule" if schedule else "now"
+
+    payload = {
+        "type": post_type,
+        "posts": [
+            {
+                "integration": {"id": integration_id},
+                "value": [
+                    {
+                        "content": content,
+                        "image": [media] if media else [],
+                    }
+                ],
+                "settings": settings,
+            }
+        ],
+    }
+    if schedule:
+        payload["date"] = schedule
+
+    resp = requests.post(
+        get_api_url("/posts"),
+        headers=api_headers(),
+        json=payload,
+        timeout=30,
+    )
+    if resp.status_code not in (200, 201):
+        print(f"Post creation failed: {resp.status_code} {resp.text[:300]}")
+        return {}
+    return resp.json()
+
+
+def build_instagram_content(clip: dict) -> str:
+    """Build Instagram post content: description + hashtags."""
+    parts = [clip.get("description", clip.get("caption_text", ""))]
+    hashtags = clip.get("hashtags", [])
+    if hashtags:
+        parts.append("\n\n" + " ".join(hashtags))
+    return "".join(parts)
+
+
+def build_youtube_content(clip: dict) -> str:
+    """Build YouTube description."""
+    parts = [clip.get("description", clip.get("caption_text", ""))]
+    hashtags = clip.get("hashtags", [])
+    if hashtags:
+        parts.append("\n\n" + " ".join(hashtags))
+    parts.append("\n\nListen to the full episode: lukeattheroost.com")
+    return "".join(parts)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Upload podcast clips to social media via Postiz")
+    parser.add_argument("clips_dir", help="Path to clips directory (e.g. clips/episode-12/)")
+    parser.add_argument("--clip", "-c", type=int, help="Upload only clip N (1-indexed)")
+    parser.add_argument("--instagram-only", action="store_true", help="Upload to Instagram only")
+    parser.add_argument("--youtube-only", action="store_true", help="Upload to YouTube only")
+    parser.add_argument("--schedule", "-s", help="Schedule time (ISO 8601, e.g. 2026-02-16T10:00:00)")
+    parser.add_argument("--yes", "-y", action="store_true", help="Skip confirmation prompt")
+    parser.add_argument("--dry-run", action="store_true", help="Show what would be uploaded without posting")
+    args = parser.parse_args()
+
+    if not POSTIZ_API_KEY:
+        print("Error: POSTIZ_API_KEY not set in .env")
+        sys.exit(1)
+
+    clips_dir = Path(args.clips_dir).expanduser().resolve()
+    metadata_path = clips_dir / "clips-metadata.json"
+
+    if not metadata_path.exists():
+        print(f"Error: No clips-metadata.json found in {clips_dir}")
+        print("Run make_clips.py first to generate clips and metadata.")
+        sys.exit(1)
+
+    with open(metadata_path) as f:
+        clips = json.load(f)
+
+    if args.clip:
+        if args.clip < 1 or args.clip > len(clips):
+            print(f"Error: Clip {args.clip} not found (have {len(clips)} clips)")
+            sys.exit(1)
+        clips = [clips[args.clip - 1]]
+
+    # Determine which platforms to post to
+    do_instagram = not args.youtube_only
+    do_youtube = not args.instagram_only
+
+    # Fetch integrations from Postiz
+    print("Fetching connected accounts from Postiz...")
+    integrations = fetch_integrations()
+
+    ig_integration = None
+    yt_integration = None
+
+    if do_instagram:
+        ig_integration = find_integration(integrations, "instagram")
+        if not ig_integration:
+            print("Warning: No Instagram account connected in Postiz")
+            do_instagram = False
+
+    if do_youtube:
+        yt_integration = find_integration(integrations, "youtube")
+        if not yt_integration:
+            print("Warning: No YouTube account connected in Postiz")
+            do_youtube = False
+
+    if not do_instagram and not do_youtube:
+        print("Error: No platforms available to upload to")
+        sys.exit(1)
+
+    # Show summary
+    platforms = []
+    if do_instagram:
+        platforms.append(f"Instagram Reels ({ig_integration.get('name', 'connected')})")
+    if do_youtube:
+        platforms.append(f"YouTube Shorts ({yt_integration.get('name', 'connected')})")
+
+    print(f"\nUploading {len(clips)} clip(s) to: {', '.join(platforms)}")
+    if args.schedule:
+        print(f"Scheduled for: {args.schedule}")
+    print()
+
+    for i, clip in enumerate(clips):
+        print(f"  {i+1}. \"{clip['title']}\" ({clip['duration']:.0f}s)")
+        print(f"     {clip.get('description', '')[:80]}")
+        print(f"     {' '.join(clip.get('hashtags', []))}")
+        print()
+
+    if args.dry_run:
+        print("Dry run — nothing uploaded.")
+        return
+
+    if not args.yes:
+        confirm = input("Proceed? [y/N] ").strip().lower()
+        if confirm != "y":
+            print("Cancelled.")
+            return
+
+    # Upload each clip
+    for i, clip in enumerate(clips):
+        clip_file = clips_dir / clip["clip_file"]
+        if not clip_file.exists():
+            print(f"  Clip {i+1}: Video file not found: {clip_file}")
+            continue
+
+        print(f"\n  Clip {i+1}: \"{clip['title']}\"")
+
+        # Upload video to Postiz
+        print(f"    Uploading {clip_file.name}...")
+        media = upload_file(clip_file)
+        if not media:
+            print(f"    Failed to upload video, skipping")
+            continue
+        print(f"    Uploaded: {media.get('path', 'ok')}")
+
+        # Post to Instagram Reels
+        if do_instagram:
+            print(f"    Posting to Instagram Reels...")
+            content = build_instagram_content(clip)
+            settings = {
+                "__type": "instagram",
+                "post_type": "reel",
+            }
+            result = create_post(
+                ig_integration["id"], content, media, settings, args.schedule
+            )
+            if result:
+                print(f"    Instagram: Posted!")
+            else:
+                print(f"    Instagram: Failed")
+
+        # Post to YouTube Shorts
+        if do_youtube:
+            print(f"    Posting to YouTube Shorts...")
+            content = build_youtube_content(clip)
+            settings = {
+                "__type": "youtube",
+                "title": clip["title"],
+                "type": "short",
+                "selfDeclaredMadeForKids": False,
+                "tags": [h.lstrip("#") for h in clip.get("hashtags", [])],
+            }
+            result = create_post(
+                yt_integration["id"], content, media, settings, args.schedule
+            )
+            if result:
+                print(f"    YouTube: Posted!")
+            else:
+                print(f"    YouTube: Failed")
+
+    print(f"\nDone!")
+
+
+if __name__ == "__main__":
+    main()
+```
+
+**Step 2: Add `POSTIZ_API_KEY` and `POSTIZ_URL` to `.env`**
+
+Add to `.env`:
+```
+POSTIZ_API_KEY=your-postiz-api-key-here
+POSTIZ_URL=https://social.lukeattheroost.com
+```
+
+Get your API key from Postiz Settings page.
+
+**Step 3: Test the script loads**
+
+Run: `python upload_clips.py --help`
+Expected: Help text displays with all flags
+
+**Step 4: Commit**
+
+```bash
+git add upload_clips.py
+git commit -m "Add upload_clips.py for posting clips to Instagram/YouTube via Postiz"
+```
+
+---
+
+### Task 4: Test with real Postiz instance
+
+**Step 1: Get Postiz API key**
+
+Go to `https://social.lukeattheroost.com` → Settings → API Keys → Generate key. Add to `.env` as `POSTIZ_API_KEY`.
+
+**Step 2: Verify integrations endpoint**
+
+Run: `python -c "from upload_clips import *; print(json.dumps(fetch_integrations(), indent=2))"`
+
+This confirms the API key works and shows connected Instagram/YouTube accounts. Note the integration IDs and provider identifiers — if `find_integration()` doesn't match correctly, adjust the provider string matching.
+
+**Step 3: Dry-run with existing clips**
+
+Run: `python upload_clips.py clips/episode-12/ --dry-run`
+Expected: Shows clip summary, "Dry run — nothing uploaded."
+
+**Step 4: Upload a single test clip**
+
+Run: `python upload_clips.py clips/episode-12/ --clip 1 --instagram-only`
+
+Check Postiz dashboard and Instagram to verify it posted as a Reel.
+
+**Step 5: Commit .env update (do NOT commit the key itself)**
+
+The `.env` is gitignored so no action needed. Just ensure the key names are documented in CLAUDE.md if desired.

docs/plans/2026-02-23-idents-playback.md

@@ -0,0 +1,402 @@
+# Idents Playback Implementation Plan
+
+> **For Claude:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task.
+
+**Goal:** Add an idents section that loads MP3s from `idents/` and plays them through the ads channel (ch 11), with a separate "idents" stem for post-production.
+
+**Architecture:** Mirrors the existing ads system — dropdown + play/stop buttons, same audio channel, mutually exclusive with ads. Idents get their own stem in stem_recorder so they can be mixed independently in post-production.
+
+**Tech Stack:** Python (FastAPI), sounddevice, librosa, vanilla JS
+
+---
+
+### Task 1: Add idents_dir to config
+
+**Files:**
+- Modify: `backend/config.py:46-47`
+
+**Step 1: Add idents_dir path**
+
+After `ads_dir` (line 46), add:
+
+```python
+    idents_dir: Path = base_dir / "idents"
+```
+
+**Step 2: Create the idents directory**
+
+```bash
+mkdir -p idents
+```
+
+**Step 3: Commit**
+
+```bash
+git add backend/config.py
+git commit -m "Add idents_dir to config"
+```
+
+---
+
+### Task 2: Add "idents" stem to stem_recorder
+
+**Files:**
+- Modify: `backend/services/stem_recorder.py:10`
+
+**Step 1: Add "idents" to STEM_NAMES**
+
+Change line 10 from:
+
+```python
+STEM_NAMES = ["host", "caller", "music", "sfx", "ads"]
+```
+
+to:
+
+```python
+STEM_NAMES = ["host", "caller", "music", "sfx", "ads", "idents"]
+```
+
+**Step 2: Add "idents" to postprod.py STEM_NAMES**
+
+In `postprod.py:20`, change:
+
+```python
+STEM_NAMES = ["host", "caller", "music", "sfx", "ads"]
+```
+
+to:
+
+```python
+STEM_NAMES = ["host", "caller", "music", "sfx", "ads", "idents"]
+```
+
+Also update `postprod.py:72` — the `remove_gaps` content detection line — add idents:
+
+```python
+content = stems["host"] + stems["caller"] + stems["sfx"] + stems["ads"] + stems["idents"]
+```
+
+And in `mix_stems` (line 411), add idents level:
+
+```python
+levels = {"host": 0, "caller": 0, "music": -6, "sfx": -10, "ads": 0, "idents": 0}
+```
+
+And in stereo pans (line 420):
+
+```python
+pans = {"host": 0.0, "caller": 0.15, "music": 0.0, "sfx": 0.0, "ads": 0.0, "idents": 0.0}
+```
+
+And in `match_voice_levels` (line 389), add "idents":
+
+```python
+for name in ["host", "caller", "ads", "idents"]:
+```
+
+And in gap removal limiter section (line 777-778):
+
+```python
+for name in ["ads", "sfx", "idents"]:
+```
+
+**Step 3: Commit**
+
+```bash
+git add backend/services/stem_recorder.py postprod.py
+git commit -m "Add idents stem to recorder and postprod"
+```
+
+---
+
+### Task 3: Add play_ident / stop_ident to audio service
+
+**Files:**
+- Modify: `backend/services/audio.py`
+
+**Step 1: Add ident state vars to __init__ (after line 40)**
+
+After the ad playback state block (lines 35-40), add:
+
+```python
+        # Ident playback state
+        self._ident_stream: Optional[sd.OutputStream] = None
+        self._ident_data: Optional[np.ndarray] = None
+        self._ident_resampled: Optional[np.ndarray] = None
+        self._ident_position: int = 0
+        self._ident_playing: bool = False
+```
+
+**Step 2: Add play_ident method (after stop_ad, ~line 1006)**
+
+Insert after `stop_ad` method. This is a copy of `play_ad` with:
+- `_ad_*` → `_ident_*`
+- Calls `self.stop_ad()` at the start (mutual exclusion)
+- Stem recording writes to `"idents"` instead of `"ads"`
+
+```python
+    def play_ident(self, file_path: str):
+        """Load and play an ident file once (no loop) on the ad channel"""
+        import librosa
+
+        path = Path(file_path)
+        if not path.exists():
+            print(f"Ident file not found: {file_path}")
+            return
+
+        self.stop_ident()
+        self.stop_ad()
+
+        try:
+            audio, sr = librosa.load(str(path), sr=self.output_sample_rate, mono=True)
+            self._ident_data = audio.astype(np.float32)
+        except Exception as e:
+            print(f"Failed to load ident: {e}")
+            return
+
+        self._ident_playing = True
+        self._ident_position = 0
+
+        if self.output_device is None:
+            num_channels = 2
+            device = None
+            device_sr = self.output_sample_rate
+            channel_idx = 0
+        else:
+            device_info = sd.query_devices(self.output_device)
+            num_channels = device_info['max_output_channels']
+            device_sr = int(device_info['default_samplerate'])
+            device = self.output_device
+            channel_idx = min(self.ad_channel, num_channels) - 1
+
+        if self.output_sample_rate != device_sr:
+            self._ident_resampled = librosa.resample(
+                self._ident_data, orig_sr=self.output_sample_rate, target_sr=device_sr
+            ).astype(np.float32)
+        else:
+            self._ident_resampled = self._ident_data
+
+        def callback(outdata, frames, time_info, status):
+            outdata[:] = 0
+            if not self._ident_playing or self._ident_resampled is None:
+                return
+
+            remaining = len(self._ident_resampled) - self._ident_position
+            if remaining >= frames:
+                chunk = self._ident_resampled[self._ident_position:self._ident_position + frames]
+                outdata[:, channel_idx] = chunk
+                if self.stem_recorder:
+                    self.stem_recorder.write_sporadic("idents", chunk.copy(), device_sr)
+                self._ident_position += frames
+            else:
+                if remaining > 0:
+                    outdata[:remaining, channel_idx] = self._ident_resampled[self._ident_position:]
+                self._ident_playing = False
+
+        try:
+            self._ident_stream = sd.OutputStream(
+                device=device,
+                channels=num_channels,
+                samplerate=device_sr,
+                dtype=np.float32,
+                callback=callback,
+                blocksize=2048
+            )
+            self._ident_stream.start()
+            print(f"Ident playback started on ch {self.ad_channel} @ {device_sr}Hz")
+        except Exception as e:
+            print(f"Ident playback error: {e}")
+            self._ident_playing = False
+
+    def stop_ident(self):
+        """Stop ident playback"""
+        self._ident_playing = False
+        if self._ident_stream:
+            self._ident_stream.stop()
+            self._ident_stream.close()
+            self._ident_stream = None
+        self._ident_position = 0
+```
+
+**Step 3: Add `self.stop_ident()` to top of play_ad (line 935)**
+
+In `play_ad`, after `self.stop_ad()` (line 935), add:
+
+```python
+        self.stop_ident()
+```
+
+**Step 4: Commit**
+
+```bash
+git add backend/services/audio.py
+git commit -m "Add play_ident/stop_ident to audio service"
+```
+
+---
+
+### Task 4: Add idents API endpoints
+
+**Files:**
+- Modify: `backend/main.py` (after ads endpoints, ~line 4362)
+
+**Step 1: Add IDENT_DISPLAY_NAMES and endpoints**
+
+Insert after the ads stop endpoint (line 4362):
+
+```python
+
+# --- Idents Endpoints ---
+
+IDENT_DISPLAY_NAMES = {}
+
+
+@app.get("/api/idents")
+async def get_idents():
+    """Get available ident tracks, shuffled"""
+    ident_list = []
+    if settings.idents_dir.exists():
+        for ext in ['*.wav', '*.mp3', '*.flac']:
+            for f in settings.idents_dir.glob(ext):
+                ident_list.append({
+                    "name": IDENT_DISPLAY_NAMES.get(f.stem, f.stem),
+                    "file": f.name,
+                    "path": str(f)
+                })
+    random.shuffle(ident_list)
+    return {"idents": ident_list}
+
+
+@app.post("/api/idents/play")
+async def play_ident(request: MusicRequest):
+    """Play an ident once on the ad channel (ch 11)"""
+    ident_path = settings.idents_dir / request.track
+    if not ident_path.exists():
+        raise HTTPException(404, "Ident not found")
+
+    if audio_service._music_playing:
+        audio_service.stop_music(fade_duration=1.0)
+        await asyncio.sleep(1.1)
+    audio_service.play_ident(str(ident_path))
+    return {"status": "playing", "track": request.track}
+
+
+@app.post("/api/idents/stop")
+async def stop_ident():
+    """Stop ident playback"""
+    audio_service.stop_ident()
+    return {"status": "stopped"}
+```
+
+**Step 2: Commit**
+
+```bash
+git add backend/main.py
+git commit -m "Add idents API endpoints"
+```
+
+---
+
+### Task 5: Add idents UI section and JS functions
+
+**Files:**
+- Modify: `frontend/index.html:113` (after ads section)
+- Modify: `frontend/js/app.js`
+
+**Step 1: Add Idents HTML section**
+
+After the Ads section closing `</section>` (line 113), add:
+
+```html
+            <!-- Idents -->
+            <section class="music-section">
+                <h2>Idents</h2>
+                <select id="ident-select"></select>
+                <div class="music-controls">
+                    <button id="ident-play-btn">Play Ident</button>
+                    <button id="ident-stop-btn">Stop</button>
+                </div>
+            </section>
+```
+
+**Step 2: Add loadIdents, playIdent, stopIdent to app.js**
+
+After `stopAd()` function (~line 773), add:
+
+```javascript
+async function loadIdents() {
+    try {
+        const res = await fetch('/api/idents');
+        const data = await res.json();
+        const idents = data.idents || [];
+
+        const select = document.getElementById('ident-select');
+        if (!select) return;
+
+        const previousValue = select.value;
+        select.innerHTML = '';
+
+        idents.forEach(ident => {
+            const option = document.createElement('option');
+            option.value = ident.file;
+            option.textContent = ident.name;
+            select.appendChild(option);
+        });
+
+        if (previousValue && [...select.options].some(o => o.value === previousValue)) {
+            select.value = previousValue;
+        }
+
+        console.log('Loaded', idents.length, 'idents');
+    } catch (err) {
+        console.error('loadIdents error:', err);
+    }
+}
+
+async function playIdent() {
+    await loadIdents();
+    const select = document.getElementById('ident-select');
+    const track = select?.value;
+    if (!track) return;
+
+    await fetch('/api/idents/play', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ track, action: 'play' })
+    });
+}
+
+async function stopIdent() {
+    await fetch('/api/idents/stop', { method: 'POST' });
+}
+```
+
+**Step 3: Add event listeners in initEventListeners**
+
+After the ads event listeners (line 190), add:
+
+```javascript
+    // Idents
+    document.getElementById('ident-play-btn')?.addEventListener('click', playIdent);
+    document.getElementById('ident-stop-btn')?.addEventListener('click', stopIdent);
+```
+
+**Step 4: Add loadIdents() to DOMContentLoaded init**
+
+After `await loadAds();` (line 59), add:
+
+```javascript
+        await loadIdents();
+```
+
+**Step 5: Bump cache buster on app.js script tag**
+
+In `index.html:243`, change `?v=17` to `?v=18`.
+
+**Step 6: Commit**
+
+```bash
+git add frontend/index.html frontend/js/app.js
+git commit -m "Add idents UI section and JS functions"
+```

docs/plans/2026-03-10-clips-page-landing-redesign.md

@@ -0,0 +1,29 @@
+# Clips Page & Landing Page Redesign
+
+## Clips Page (`/clips`)
+
+Responsive grid gallery of podcast clips with click-to-play YouTube embeds.
+
+**Grid:** 3 columns desktop, 2 tablet, 1 mobile. Cards use 9:16 vertical aspect ratio.
+
+**Card pre-click:** Dark bg-light card with clip title (bold), episode label, centered orange play button, description text below. Matches site aesthetic.
+
+**Card playing:** Click swaps card for YouTube Shorts iframe (`youtube-nocookie.com`, autoplay). Fills same 9:16 space.
+
+**Data:** Static `website/data/clips.json` aggregated from per-episode `clips-metadata.json` files. Each entry: title, description, episode_number, optional `youtube_id`. Cards without youtube_id show no play button.
+
+**Featured row:** Top 3 hand-picked clips displayed larger, followed by full grid below.
+
+**Nav:** "Clips" added to hero secondary links and footer nav.
+
+## Landing Page Improvements
+
+**About section** (between hero and episodes): Centered text block. Show description + AI teaser line ("Part human callers, part AI-generated characters, fully unhinged advice") + "See how it works" link. No card background.
+
+**Clips highlight** (between about and episodes): Horizontal row of 3 featured clips, same card style as clips page. "Best Clips" header with "See all clips" link.
+
+**Final section order:** Banner → Hero → About → Featured Clips → Episodes → Testimonials → Footer
+
+## How It Works — Reaper Video
+
+New "Post-Production Automation" section with native `<video>` tag (mp4 on CDN). Shows Reaper automating silence removal, ad ducking, loudness normalization. Wrapped in hiw-hero-card style container.

docs/plans/2026-03-30-show-quality-fixes.md

@@ -0,0 +1,297 @@
+# Show Quality Fixes — Episode 47 Post-Mortem
+
+> **For Claude:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task.
+
+**Goal:** Fix 5 bugs that ruined tonight's show: theme ignored by callers, wrong LLM models assigned, phonetic pronunciation mangling, voice-age mismatch, and low minimum response threshold.
+
+**Architecture:** All fixes are in `backend/main.py` except voice-age matching which also touches `backend/services/tts.py` voice matching logic. Each fix is independent — no ordering dependencies between tasks.
+
+**Tech Stack:** Python, FastAPI
+
+---
+
+### Task 1: Regenerate caller backgrounds when theme is set
+
+**Problem:** `_pregenerate_backgrounds()` runs on startup when `session.show_theme` is still `""`. Setting theme via `POST /api/show-theme` only stores the string — doesn't regenerate. Callers have zero theme connection.
+
+**Files:**
+- Modify: `backend/main.py:9891-9900` (`set_show_theme` endpoint)
+- Modify: `backend/main.py:5899-5927` (`_pregenerate_backgrounds`)
+
+**Step 1: Modify `set_show_theme` to regenerate unused caller backgrounds**
+
+In `backend/main.py`, replace the `set_show_theme` endpoint (lines 9891-9900):
+
+```python
+@app.post("/api/show-theme")
+async def set_show_theme(data: dict):
+    theme = data.get("theme", "").strip()[:100]
+    old_theme = session.show_theme
+    session.show_theme = theme
+    if theme:
+        print(f"[Theme] Show theme set: {theme}")
+    elif old_theme:
+        print(f"[Theme] Show theme cleared (was: {old_theme})")
+
+    # Regenerate backgrounds for callers that haven't been on air yet
+    if theme != old_theme:
+        unused_keys = [k for k in CALLER_BASES if k not in session.used_callers]
+        if unused_keys:
+            print(f"[Theme] Regenerating {len(unused_keys)} unused caller backgrounds for theme: {theme or '(none)'}")
+            asyncio.create_task(_regenerate_backgrounds_for_keys(unused_keys))
+
+    return {"theme": session.show_theme}
+```
+
+**Step 2: Add `_regenerate_backgrounds_for_keys` helper**
+
+Add this right after `_pregenerate_backgrounds()` (after line 5927):
+
+```python
+async def _regenerate_backgrounds_for_keys(keys: list[str]):
+    """Regenerate backgrounds for specific caller keys (e.g. after theme change)."""
+    tasks = []
+    for key in keys:
+        base = CALLER_BASES.get(key)
+        if base and not base.get("returning"):
+            tasks.append((key, _generate_caller_background_llm(base)))
+
+    if not tasks:
+        return
+
+    results = await asyncio.gather(*[t[1] for t in tasks], return_exceptions=True)
+    for (key, _), result in zip(tasks, results):
+        if isinstance(result, Exception):
+            print(f"[Theme] Regen failed for caller {key}: {result}")
+        else:
+            session.caller_backgrounds[key] = result
+            # Clear cached model so it re-evaluates with new style
+            session.caller_models.pop(key, None)
+
+    print(f"[Theme] Regenerated {sum(1 for r in results if not isinstance(r, Exception))}/{len(tasks)} backgrounds")
+    _match_voices_to_styles()
+    _sort_caller_queue()
+```
+
+**Step 3: Verify `used_callers` exists on session**
+
+Check that `session.used_callers` tracks which callers have already been on air. If it doesn't exist, use `session.call_history` caller keys instead.
+
+**Step 4: Test manually**
+
+```bash
+# Start server
+python -m uvicorn backend.main:app --reload --reload-dir backend --host 0.0.0.0 --port 8000
+# Set theme and check logs for "[Theme] Regenerating..." messages
+curl -X POST http://localhost:8000/api/show-theme -H "Content-Type: application/json" -d '{"theme": "Road Stories"}'
+```
+
+**Step 5: Commit**
+
+```bash
+git add backend/main.py
+git commit -m "Regenerate caller backgrounds when show theme is set"
+```
+
+---
+
+### Task 2: Fix style-to-model matching race condition
+
+**Problem:** `get_caller_model()` is called before `caller_styles` is populated. `caller_styles.get(key)` returns `""`, `_normalize_style_key("")` returns `""`, no match in `caller_model_map` → falls through to `caller_model_pool[0]` (grok-4.1-fast) for everyone.
+
+**Files:**
+- Modify: `backend/main.py:6848-6875` (`get_caller_model`)
+
+**Step 1: Fix `get_caller_model` to defer assignment when style is unknown**
+
+Replace `get_caller_model` (lines 6848-6875):
+
+```python
+    def get_caller_model(self, caller_key: str) -> str | None:
+        """Get the assigned model for a caller, or assign one based on strategy.
+        Returns None to use default category routing."""
+        if self.caller_model_strategy == "single":
+            return None  # use default category_models["caller_dialog"]
+
+        # Already assigned — keep consistent for the whole call
+        if caller_key in self.caller_models:
+            return self.caller_models[caller_key]
+
+        model = None
+        if self.caller_model_strategy == "cycle":
+            if self.caller_model_pool:
+                model = self.caller_model_pool[self._caller_model_cycle_idx % len(self.caller_model_pool)]
+                self._caller_model_cycle_idx += 1
+        elif self.caller_model_strategy == "style_matched":
+            raw_style = self.caller_styles.get(caller_key, "")
+            style_key = _normalize_style_key(raw_style) if raw_style else ""
+            if style_key:
+                model = self.caller_model_map.get(style_key)
+            if not model:
+                # Style not yet populated or no mapping — use fallback, not pool[0]
+                model = self.caller_model_fallback
+
+        if model:
+            self.caller_models[caller_key] = model
+            caller_name = CALLER_BASES.get(caller_key, {}).get("name", caller_key)
+            style_info = self.caller_styles.get(caller_key, "unknown")
+            print(f"[CallerModel] Assigned {model} to {caller_name} (style={_normalize_style_key(style_info) if style_info else 'none'}, strategy={self.caller_model_strategy})")
+
+        return model
+```
+
+The key change: when `style_key` is empty (style not yet populated) or has no mapping, use `caller_model_fallback` (claude-sonnet-4.6) instead of `caller_model_pool[0]` (grok-4.1-fast). Claude Sonnet is a much safer default — empathetic, verbose, coherent.
+
+**Step 2: Commit**
+
+```bash
+git add backend/main.py
+git commit -m "Fix style-to-model race condition — use fallback instead of pool[0]"
+```
+
+---
+
+### Task 3: Fix pronunciation fixes producing literal phonetic text
+
+**Problem:** `_PRONUNCIATION_FIXES` replaces "Animas" with "Ah nee mahs" as literal text. TTS reads each word separately ("Ah" "nee" "mahs") instead of blending into the intended pronunciation.
+
+**Files:**
+- Modify: `backend/main.py:9141-9152` (`_PRONUNCIATION_FIXES`)
+- Modify: `backend/main.py:9212-9216` (`_apply_pronunciation_fixes`)
+
+**Step 1: Remove pronunciation fixes that sound worse than originals**
+
+The Inworld TTS actually handles most proper nouns fine. The fixes were added speculatively and cause more harm than good. Remove the place names that TTS can handle, keep only abbreviations:
+
+Replace `_PRONUNCIATION_FIXES` (lines 9141-9152):
+
+```python
+_PRONUNCIATION_FIXES = {
+    "Castopod": "Casto pod",
+    "vs": "versus",
+    "govt": "government",
+    "dept": "department",
+}
+```
+
+Remove `Lordsburg`, `Hachita`, `Deming`, `Bootheel`, `Animas`, and `Rodeo`. These place names either sound fine through TTS or the phonetic replacement sounds worse.
+
+**Step 2: Commit**
+
+```bash
+git add backend/main.py
+git commit -m "Remove pronunciation fixes that produce worse TTS output"
+```
+
+---
+
+### Task 4: Add age-awareness to voice matching
+
+**Problem:** Brandy (55 years old) got "Kayla" (young-sounding voice). `_match_voices_to_styles()` scores on style dimensions (weight, energy, warmth, age_feel) but the `age_feel` preference comes from the communication style, not the character's actual age. A "confrontational" style prefers `age_feel: None` (no preference), so a 55-year-old can get a young voice.
+
+**Files:**
+- Modify: `backend/main.py:6106-6156` (`_match_voices_to_styles`)
+
+**Step 1: Add character age to voice scoring**
+
+In `_match_voices_to_styles`, after getting the style preferences, override `age_feel` based on the caller's actual age from their background:
+
+```python
+def _match_voices_to_styles():
+    """Re-assign voices to match caller communication styles after backgrounds are generated."""
+    from .services.tts import VOICE_PROFILES
+
+    for key, base in CALLER_BASES.items():
+        if base.get("returning"):
+            continue
+
+        style_raw = session.caller_styles.get(key, "")
+        if not style_raw:
+            continue
+
+        style_key = _normalize_style_key(style_raw)
+        prefs = STYLE_VOICE_PREFERENCES.get(style_key)
+        if not prefs:
+            continue
+
+        # Copy prefs so we don't mutate the shared dict
+        prefs = dict(prefs)
+
+        # Override age_feel based on character's actual age
+        bg = session.caller_backgrounds.get(key)
+        if isinstance(bg, CallerBackground) and bg.age:
+            if bg.age >= 50:
+                prefs["age_feel"] = "mature"
+            elif bg.age >= 35:
+                prefs["age_feel"] = "middle"
+            elif bg.age < 25:
+                prefs["age_feel"] = "young"
+            # 25-34: keep style preference or None
+
+        gender = base["gender"]
+        pool = INWORLD_MALE_VOICES if gender == "male" else INWORLD_FEMALE_VOICES
+        voice_pool = [v for v in pool if v not in BLACKLISTED_VOICES]
+
+        scored = []
+        for voice_name in voice_pool:
+            profile = VOICE_PROFILES.get(voice_name)
+            if not profile:
+                scored.append((voice_name, 0))
+                continue
+            score = 0
+            for dim in ["weight", "energy", "warmth", "age_feel"]:
+                pref_val = prefs.get(dim)
+                if pref_val and profile.get(dim) == pref_val:
+                    score += 1
+            scored.append((voice_name, score))
+
+        if scored:
+            names = [s[0] for s in scored]
+            weights = [max(1, s[1] * 3) for s in scored]
+            chosen = random.choices(names, weights=weights, k=1)[0]
+
+            used_voices = {CALLER_BASES[k]["voice"] for k in CALLER_BASES if k != key and "voice" in CALLER_BASES[k]}
+            if chosen in used_voices:
+                alternatives = [(n, w) for n, w in zip(names, weights) if n not in used_voices]
+                if alternatives:
+                    alt_names, alt_weights = zip(*alternatives)
+                    chosen = random.choices(alt_names, weights=alt_weights, k=1)[0]
+
+            old_voice = base.get("voice", "")
+            base["voice"] = chosen
+            if old_voice != chosen:
+                print(f"[VoiceMatch] {base.get('name', key)}: {old_voice} → {chosen} (style: {style_key}, age: {bg.age if isinstance(bg, CallerBackground) else '?'})")
+```
+
+**Step 2: Commit**
+
+```bash
+git add backend/main.py
+git commit -m "Add age-awareness to voice matching — 55yo won't get young voices"
+```
+
+---
+
+### Task 5: Raise minimum response word count
+
+**Problem:** `MIN_RESPONSE_WORDS = 30` lets through fragmented, telegram-style responses that are technically 30+ words but terrible radio.
+
+**Files:**
+- Modify: `backend/main.py:8844` (`MIN_RESPONSE_WORDS`)
+
+**Step 1: Raise the minimum**
+
+Change line 8844:
+
+```python
+MIN_RESPONSE_WORDS = 50  # Retry if response is shorter than this
+```
+
+50 words is roughly 2-3 spoken sentences — enough to be a coherent radio response without being overly demanding for short-form exchanges.
+
+**Step 2: Commit**
+
+```bash
+git add backend/main.py
+git commit -m "Raise MIN_RESPONSE_WORDS from 30 to 50"
+```

fetch_music.py

@@ -0,0 +1,261 @@
+"""Fetch instrumental background music from Jamendo for the radio show.
+
+Pixabay has no public music API — this uses Jamendo's free API instead.
+All tracks are Creative Commons licensed. Attribution is saved to music/CREDITS.txt.
+
+Setup: Get a free client_id at https://devportal.jamendo.com
+       Add JAMENDO_CLIENT_ID=your_id to .env
+
+Usage:
+    python fetch_music.py                    # download 20 tracks across all genres
+    python fetch_music.py --genre jazz       # download jazz only
+    python fetch_music.py --count 50         # download 50 tracks
+    python fetch_music.py --list             # just list available tracks, don't download
+"""
+
+import argparse
+import os
+import re
+import sys
+from pathlib import Path
+
+import httpx
+from dotenv import load_dotenv
+
+load_dotenv()
+
+MUSIC_DIR = Path(__file__).parent / "music"
+CREDITS_FILE = MUSIC_DIR / "CREDITS.txt"
+API_BASE = "https://api.jamendo.com/v3.0"
+
+# Genres good for a late-night radio show
+GENRES = ["jazz", "lofi", "blues", "ambient", "acoustic", "funk", "chill"]
+
+# Map search tags to labels that _detect_genre() in main.py can match
+# jazz, blues, funk, lo-fi are already in GENRE_KEYWORDS
+# ambient, acoustic, chill would need to be added for auto-detection
+GENRE_LABELS = {
+    "jazz": "Jazz",
+    "lofi": "Lo-Fi",
+    "blues": "Blues",
+    "ambient": "Ambient",
+    "acoustic": "Acoustic",
+    "funk": "Funk",
+    "chill": "Chill",
+}
+
+
+def get_client_id():
+    key = os.getenv("JAMENDO_CLIENT_ID")
+    if not key:
+        print("Error: JAMENDO_CLIENT_ID not found in .env")
+        print("Get one free at https://devportal.jamendo.com")
+        sys.exit(1)
+    return key
+
+
+def sanitize_filename(name: str) -> str:
+    return re.sub(r'[<>:"/\\|?*]', '', name).strip()
+
+
+def _has_vocals(track: dict) -> bool:
+    """Check musicinfo for vocal indicators — catches tracks Jamendo mis-tagged as instrumental."""
+    mi = track.get("musicinfo", {})
+    # Check the vocalinstrumental field in musicinfo (separate from the API filter)
+    vi = mi.get("vocalinstrumental")
+    if vi and vi.lower() == "vocal":
+        return True
+    # Check tags for vocal/singing indicators
+    tags = mi.get("tags", {})
+    # tags can be {"genres": [...], "instruments": [...], "vartags": [...]}
+    all_tags = []
+    if isinstance(tags, dict):
+        for v in tags.values():
+            if isinstance(v, list):
+                all_tags.extend(t.lower() for t in v)
+    elif isinstance(tags, list):
+        all_tags = [t.lower() for t in tags]
+    vocal_tags = {"vocals", "vocal", "singing", "singer", "voice", "lyrics",
+                  "rap", "hiphop", "hip-hop", "spoken", "spoken word"}
+    if vocal_tags & set(all_tags):
+        return True
+    # Check track name for vocal giveaways
+    name_lower = track.get("name", "").lower()
+    if any(w in name_lower for w in ["feat.", "ft.", "vocal", "remix vocal", "(voice"]):
+        return True
+    return False
+
+
+def search_tracks(client: httpx.Client, client_id: str, genre: str, limit: int = 20) -> list[dict]:
+    # Request more than needed so we can filter out vocal false positives
+    fetch_limit = min(limit * 3, 200)
+    params = {
+        "client_id": client_id,
+        "format": "json",
+        "limit": fetch_limit,
+        "vocalinstrumental": "instrumental",
+        "fuzzytags": genre,
+        "durationbetween": "60_300",
+        "include": "musicinfo+licenses",
+        "order": "popularity_total",
+    }
+
+    resp = client.get(f"{API_BASE}/tracks/", params=params)
+    resp.raise_for_status()
+    data = resp.json()
+
+    if data["headers"]["status"] != "success":
+        print(f"  API error: {data['headers'].get('error_message', 'unknown')}")
+        return []
+
+    results = data.get("results", [])
+    # Post-filter: reject tracks with vocal indicators despite the API filter
+    filtered = []
+    for t in results:
+        if _has_vocals(t):
+            print(f"    SKIP (vocals detected): {t.get('artist_name', '?')} - {t.get('name', '?')}")
+            continue
+        filtered.append(t)
+        if len(filtered) >= limit:
+            break
+
+    skipped = len(results) - len(filtered)
+    if skipped:
+        print(f"  (filtered out {skipped} tracks with vocal indicators)")
+    return filtered
+
+
+def make_filename(track: dict, genre_tag: str) -> str:
+    artist = sanitize_filename(track.get("artist_name", "Unknown"))
+    title = sanitize_filename(track.get("name", "Untitled"))
+    label = GENRE_LABELS.get(genre_tag, genre_tag.title())
+
+    # Include genre tag if not already detectable from artist/title
+    lower = f"{artist} {title}".lower()
+    needs_tag = not any(kw in lower for kw in [genre_tag, label.lower()])
+
+    if needs_tag:
+        return f"{artist} - {title} [{label}].mp3"
+    return f"{artist} - {title}.mp3"
+
+
+def download_track(client: httpx.Client, track: dict, filepath: Path, index: int, total: int) -> bool:
+    url = track.get("audiodownload")
+    if not url:
+        print(f"  [{index}/{total}] SKIP (no download URL): {track['name']}")
+        return False
+
+    if not track.get("audiodownload_allowed", True):
+        print(f"  [{index}/{total}] SKIP (download not allowed): {track['name']}")
+        return False
+
+    print(f"  [{index}/{total}] Downloading: {filepath.name}...", end=" ", flush=True)
+    resp = client.get(url, follow_redirects=True)
+    resp.raise_for_status()
+    filepath.write_bytes(resp.content)
+    size_mb = len(resp.content) / (1024 * 1024)
+    dur = track.get("duration", 0)
+    print(f"{size_mb:.1f} MB, {dur // 60}:{dur % 60:02d}")
+    return True
+
+
+def save_credit(track: dict, filename: str):
+    artist = track.get("artist_name", "Unknown")
+    title = track.get("name", "Untitled")
+    license_url = track.get("license_ccurl", "")
+    share_url = track.get("shareurl", "")
+
+    line = f"{filename} | {artist} - {title} | {license_url} | {share_url}\n"
+
+    existing = CREDITS_FILE.read_text() if CREDITS_FILE.exists() else ""
+    if filename not in existing:
+        with open(CREDITS_FILE, "a") as f:
+            if not existing:
+                f.write("# Music Credits (Jamendo - Creative Commons)\n")
+                f.write("# File | Artist - Title | License | URL\n\n")
+            f.write(line)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Download instrumental music from Jamendo")
+    parser.add_argument("--genre", choices=GENRES, help="Download only this genre")
+    parser.add_argument("--count", type=int, default=20, help="Total tracks to download (default: 20)")
+    parser.add_argument("--list", action="store_true", help="List available tracks without downloading")
+    args = parser.parse_args()
+
+    client_id = get_client_id()
+    MUSIC_DIR.mkdir(exist_ok=True)
+
+    genres = [args.genre] if args.genre else GENRES
+    per_genre = max(1, args.count // len(genres))
+    remainder = args.count - per_genre * len(genres)
+
+    all_tracks = []
+    seen_ids = set()
+
+    with httpx.Client(timeout=30) as api_client:
+        for i, genre in enumerate(genres):
+            limit = per_genre + (1 if i < remainder else 0)
+            if limit <= 0:
+                continue
+            print(f"Searching {genre}...", end=" ", flush=True)
+            tracks = search_tracks(api_client, client_id, genre, limit)
+            # Deduplicate across genres
+            added = 0
+            for t in tracks:
+                if t["id"] not in seen_ids and added < limit:
+                    t["_genre_tag"] = genre
+                    all_tracks.append(t)
+                    seen_ids.add(t["id"])
+                    added += 1
+            print(f"{added} tracks")
+
+    if not all_tracks:
+        print("No tracks found.")
+        return
+
+    if args.list:
+        print(f"\n{'#':<4} {'Genre':<10} {'Artist':<25} {'Title':<40} {'Duration':<8}")
+        print("-" * 90)
+        for i, t in enumerate(all_tracks, 1):
+            dur = f"{t['duration'] // 60}:{t['duration'] % 60:02d}"
+            artist = t["artist_name"][:24]
+            title = t["name"][:39]
+            label = GENRE_LABELS.get(t["_genre_tag"], t["_genre_tag"])
+            print(f"{i:<4} {label:<10} {artist:<25} {title:<40} {dur:<8}")
+        print(f"\n{len(all_tracks)} tracks available")
+        return
+
+    # Download phase
+    downloaded = 0
+    skipped_exists = 0
+    skipped_error = 0
+
+    with httpx.Client(timeout=120, follow_redirects=True) as dl_client:
+        for i, track in enumerate(all_tracks, 1):
+            filename = make_filename(track, track["_genre_tag"])
+            filepath = MUSIC_DIR / filename
+
+            if filepath.exists():
+                print(f"  [{i}/{len(all_tracks)}] EXISTS: {filename}")
+                skipped_exists += 1
+                continue
+
+            try:
+                if download_track(dl_client, track, filepath, i, len(all_tracks)):
+                    save_credit(track, filename)
+                    downloaded += 1
+                else:
+                    skipped_error += 1
+            except Exception as e:
+                print(f"  [{i}/{len(all_tracks)}] ERROR: {e}")
+                # Clean up partial download
+                if filepath.exists():
+                    filepath.unlink()
+                skipped_error += 1
+
+    print(f"\nDone: {downloaded} downloaded, {skipped_exists} existed, {skipped_error} skipped")
+
+
+if __name__ == "__main__":
+    main()

frontend/index.html

@@ -3,17 +3,41 @@
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>AI Radio Show</title>
-    <link rel="stylesheet" href="/css/style.css">
+    <title>Luke at The Roost</title>
+    <link rel="stylesheet" href="/css/style.css?v=2">
 </head>
 <body>
     <div id="app">
         <header>
-            <h1>AI Radio Show</h1>
+            <h1>Luke at The Roost</h1>
             <div class="header-buttons">
+                <button id="on-air-btn" class="on-air-btn off">OFF AIR</button>
+                <button id="rec-btn" class="rec-btn" title="Record stems for post-production">REC</button>
                 <button id="new-session-btn" class="new-session-btn">New Session</button>
+                <button id="export-session-btn">Export</button>
+                <button id="preflight-btn" class="preflight-btn">Preflight</button>
                 <button id="settings-btn">Settings</button>
             </div>
+            <div class="theme-bar">
+                <label for="show-theme-input" class="theme-label">Theme:</label>
+                <input type="text" id="show-theme-input" class="theme-input" placeholder="e.g. St. Patrick's Day" maxlength="100">
+                <button id="set-theme-btn" class="theme-btn set" title="Set show theme">Set</button>
+                <button id="clear-theme-btn" class="theme-btn clear hidden" title="Clear theme">&#x2715;</button>
+            </div>
+            <div id="show-clock" class="show-clock">
+                <span class="clock-time" id="clock-time"></span>
+                <span id="show-timers" class="show-timers hidden">
+                    <span class="clock-divider">|</span>
+                    <span class="clock-label">On Air:</span>
+                    <span class="clock-value" id="clock-runtime">0:00:00</span>
+                    <span class="clock-divider">|</span>
+                    <span class="clock-label">Est. Final:</span>
+                    <span class="clock-value clock-estimate" id="clock-estimate">0:00</span>
+                    <span class="clock-divider">|</span>
+                    <span class="clock-label">Cost:</span>
+                    <span class="clock-value clock-cost" id="clock-cost">$0.00</span>
+                </span>
+            </div>
         </header>
 
         <main>
@@ -21,14 +45,95 @@
             <section class="callers-section">
                 <h2>Callers <span id="session-id" class="session-id"></span></h2>
                 <div id="callers" class="caller-grid"></div>
+                <!-- Active Call Indicator -->
+                <div id="active-call" class="active-call hidden">
+                    <div id="real-caller-info" class="caller-info hidden">
+                        <span class="caller-type real">LIVE</span>
+                        <span id="real-caller-name"></span>
+                        <span id="real-caller-channel" class="channel-badge"></span>
+                        <span id="real-caller-duration" class="call-duration"></span>
+                        <button id="hangup-real-btn" class="hangup-btn small">Hang Up</button>
+                    </div>
+                    <div id="ai-caller-info" class="caller-info hidden">
+                        <span class="caller-type ai">AI</span>
+                        <span id="ai-caller-name"></span>
+                        <div class="ai-controls">
+                            <div class="mode-toggle">
+                                <button id="mode-manual" class="mode-btn active">Manual</button>
+                                <button id="mode-auto" class="mode-btn">Auto</button>
+                            </div>
+                            <button id="ai-respond-btn" class="respond-btn">Let them respond</button>
+                        </div>
+                        <button id="hangup-ai-btn" class="hangup-btn small">Hang Up</button>
+                    </div>
+                    <label class="auto-followup-label">
+                        <input type="checkbox" id="auto-followup"> Auto Follow-Up
+                    </label>
+                </div>
                 <div id="call-status" class="call-status">No active call</div>
-                <div id="caller-background" class="caller-background hidden"></div>
-                <button id="hangup-btn" class="hangup-btn" disabled>Hang Up</button>
+                <div id="caller-info-panel" class="caller-info-panel hidden">
+                    <div class="caller-info-row">
+                        <span id="caller-shape-badge" class="info-badge shape"></span>
+                        <span id="caller-energy-badge" class="info-badge energy"></span>
+                        <span id="caller-emotion" class="info-badge emotion"></span>
+                        <span id="caller-model-badge" class="info-badge model"></span>
+                        <select id="caller-model-override" class="caller-model-override hidden"></select>
+                    </div>
+                    <div id="caller-signature" class="caller-signature"></div>
+                    <div id="caller-situation" class="caller-situation"></div>
+                    <details id="caller-background-details" class="caller-background-full">
+                        <summary>Full Background</summary>
+                        <div id="caller-background"></div>
+                    </details>
+                </div>
+                <div class="call-actions">
+                    <button id="wrapup-btn" class="wrapup-btn" disabled>Wrap It Up <span class="shortcut-label">W</span></button>
+                    <button id="hangup-btn" class="hangup-btn" disabled>Hang Up <span class="shortcut-label">H</span></button>
+                </div>
+            </section>
+
+            <!-- Call Queue -->
+            <section class="queue-section">
+                <h2>Incoming Calls <span class="section-subtitle">(208) 439-5853</span></h2>
+                <div id="call-queue" class="call-queue">
+                    <div class="queue-empty">No callers waiting</div>
+                </div>
+            </section>
+
+            <!-- Voicemail -->
+            <section class="voicemail-section">
+                <h2>Voicemail <span id="voicemail-badge" class="voicemail-badge hidden">0</span></h2>
+                <div id="voicemail-list" class="voicemail-list">
+                    <div class="queue-empty">No voicemails</div>
+                </div>
+            </section>
+
+            <!-- Listener Emails -->
+            <section class="voicemail-section">
+                <h2>Emails <span id="email-badge" class="voicemail-badge hidden">0</span></h2>
+                <div id="email-list" class="voicemail-list email-list">
+                    <div class="queue-empty">No emails</div>
+                </div>
             </section>
 
             <!-- Chat -->
             <section class="chat-section">
                 <div id="chat" class="chat-log"></div>
+                <div class="devon-bar">
+                    <div class="devon-ask-row">
+                        <input type="text" id="devon-input" placeholder="Ask Devon..." class="devon-input">
+                        <button id="devon-ask-btn" class="devon-ask-btn">Ask <span class="shortcut-label">D</span></button>
+                        <button id="devon-interject-btn" class="devon-interject-btn" title="Devon interjects on current conversation">Interject</button>
+                        <label class="devon-monitor-label" title="Devon auto-monitors conversations">
+                            <input type="checkbox" id="devon-monitor" checked> Monitor
+                        </label>
+                    </div>
+                    <div id="devon-suggestion" class="devon-suggestion hidden">
+                        <span class="devon-suggestion-text">Devon has something</span>
+                        <button id="devon-play-btn" class="devon-play-btn">Play</button>
+                        <button id="devon-dismiss-btn" class="devon-dismiss-btn">Dismiss</button>
+                    </div>
+                </div>
                 <div class="talk-controls">
                     <button id="talk-btn" class="talk-btn">Hold to Talk</button>
                     <button id="type-btn" class="type-btn">Type</button>
@@ -36,16 +141,36 @@
                 <div id="status" class="status hidden"></div>
             </section>
 
-            <!-- Music -->
-            <section class="music-section">
-                <h2>Music</h2>
-                <select id="track-select"></select>
-                <div class="music-controls">
-                    <button id="play-btn">Play</button>
-                    <button id="stop-btn">Stop</button>
-                    <input type="range" id="volume" min="0" max="100" value="30">
-                </div>
-            </section>
+            <!-- Music / Ads / Idents -->
+            <div class="media-row">
+                <section class="music-section genre-section">
+                    <h2>Music <span class="shortcut-label">M</span></h2>
+                    <div id="genre-buttons" class="genre-grid"></div>
+                    <div id="now-playing" class="now-playing hidden">
+                        <span id="now-playing-text" class="now-playing-text"></span>
+                        <button id="stop-btn" class="now-playing-stop">Stop</button>
+                        <input type="range" id="volume" min="0" max="100" value="30" class="now-playing-volume">
+                    </div>
+                </section>
+
+                <section class="music-section">
+                    <h2>Ads</h2>
+                    <select id="ad-select"></select>
+                    <div class="music-controls">
+                        <button id="ad-play-btn">Play Ad</button>
+                        <button id="ad-stop-btn">Stop</button>
+                    </div>
+                </section>
+
+                <section class="music-section">
+                    <h2>Idents</h2>
+                    <select id="ident-select"></select>
+                    <div class="music-controls">
+                        <button id="ident-play-btn">Play Ident</button>
+                        <button id="ident-stop-btn">Stop</button>
+                    </div>
+                </section>
+            </div>
 
             <!-- Sound Effects -->
             <section class="sounds-section">
@@ -58,6 +183,7 @@
                 <div class="log-header">
                     <h2>Server Log</h2>
                     <div class="server-controls">
+                        <button id="log-toggle-btn" class="log-toggle-btn">Show ▼</button>
                         <button id="restart-server-btn" class="server-btn restart">Restart</button>
                         <button id="stop-server-btn" class="server-btn stop">Stop</button>
                         <label class="auto-scroll-label">
@@ -65,7 +191,9 @@
                         </label>
                     </div>
                 </div>
-                <div id="server-log" class="server-log"></div>
+                <div class="log-body collapsed">
+                    <div id="server-log" class="server-log"></div>
+                </div>
             </section>
         </main>
 
@@ -76,7 +204,7 @@
 
                 <!-- Audio Devices -->
                 <div class="settings-group">
-                    <h3>Audio Routing</h3>
+                    <h3>Audio Devices</h3>
                     <div class="device-row">
                         <label>
                             Input Device
@@ -84,7 +212,7 @@
                         </label>
                         <label>
                             Ch
-                            <input type="number" id="input-channel" value="1" min="1" max="16" class="channel-input">
+                            <input type="number" id="input-channel" value="1" min="1" max="32" class="channel-input">
                         </label>
                     </div>
                     <div class="device-row">
@@ -93,41 +221,100 @@
                             <select id="output-device"></select>
                         </label>
                     </div>
-                    <div class="channel-row">
-                        <label>Caller Ch <input type="number" id="caller-channel" value="1" min="1" max="16" class="channel-input"></label>
-                        <label>Music Ch <input type="number" id="music-channel" value="2" min="1" max="16" class="channel-input"></label>
-                        <label>SFX Ch <input type="number" id="sfx-channel" value="3" min="1" max="16" class="channel-input"></label>
+                </div>
+
+                <div class="settings-group">
+                    <h3>Output Routing</h3>
+                    <div class="routing-grid">
+                        <div class="routing-item">
+                            <span class="routing-label">AI Caller</span>
+                            <input type="number" id="caller-channel" value="3" min="1" max="32" class="channel-input">
+                        </div>
+                        <div class="routing-item">
+                            <span class="routing-label">Devon</span>
+                            <input type="number" id="devon-channel" value="17" min="1" max="32" class="channel-input">
+                        </div>
+                        <div class="routing-item">
+                            <span class="routing-label">Live Caller</span>
+                            <input type="number" id="live-caller-channel" value="9" min="1" max="32" class="channel-input">
+                        </div>
+                        <div class="routing-item">
+                            <span class="routing-label">Music</span>
+                            <input type="number" id="music-channel" value="5" min="1" max="32" class="channel-input">
+                        </div>
+                        <div class="routing-item">
+                            <span class="routing-label">SFX</span>
+                            <input type="number" id="sfx-channel" value="7" min="1" max="32" class="channel-input">
+                        </div>
+                        <div class="routing-item">
+                            <span class="routing-label">Ads</span>
+                            <input type="number" id="ad-channel" value="11" min="1" max="32" class="channel-input">
+                        </div>
+                        <div class="routing-item">
+                            <span class="routing-label">Idents</span>
+                            <input type="number" id="ident-channel" value="15" min="1" max="32" class="channel-input">
+                        </div>
                     </div>
                 </div>
 
                 <!-- LLM Settings -->
                 <div class="settings-group">
-                    <h3>LLM Provider</h3>
-                    <label>
-                        Provider
-                        <select id="provider">
-                            <option value="openrouter">OpenRouter</option>
-                            <option value="ollama">Ollama</option>
-                        </select>
-                    </label>
+                    <h3>LLM Model Routing</h3>
+                    <div class="model-routing-grid">
+                        <div class="model-routing-item">
+                            <span class="model-routing-label">Caller Dialog</span>
+                            <select id="model-caller_dialog" class="model-select"></select>
+                        </div>
+                        <div class="model-routing-item">
+                            <span class="model-routing-label">Devon Monitor</span>
+                            <select id="model-devon_monitor" class="model-select"></select>
+                        </div>
+                        <div class="model-routing-item">
+                            <span class="model-routing-label">Devon Ask</span>
+                            <select id="model-devon_ask" class="model-select"></select>
+                        </div>
+                        <div class="model-routing-item">
+                            <span class="model-routing-label">Backgrounds</span>
+                            <select id="model-background_gen" class="model-select"></select>
+                        </div>
+                        <div class="model-routing-item">
+                            <span class="model-routing-label">Call Summary</span>
+                            <select id="model-call_summary" class="model-select"></select>
+                        </div>
+                        <div class="model-routing-item">
+                            <span class="model-routing-label">News</span>
+                            <select id="model-news_summary" class="model-select"></select>
+                        </div>
+                    </div>
+                </div>
 
-                    <div id="openrouter-settings">
+                <!-- Caller Model Routing -->
+                <div class="settings-group">
+                    <h3>Caller Models</h3>
+                    <div class="caller-model-row">
                         <label>
-                            Model
-                            <select id="openrouter-model"></select>
+                            Strategy
+                            <select id="cm-strategy">
+                                <option value="single">Single Model</option>
+                                <option value="cycle">Cycle Models</option>
+                                <option value="style_matched">Style-Matched</option>
+                            </select>
                         </label>
                     </div>
-
-                    <div id="ollama-settings" class="hidden">
+                    <div id="cm-pool-section" class="hidden">
                         <label>
-                            Model
-                            <select id="ollama-model"></select>
+                            Model Pool
+                            <input type="text" id="cm-pool" class="cm-pool-input" placeholder="x-ai/grok-4, deepseek/deepseek-v3.2, ...">
                         </label>
+                    </div>
+                    <div id="cm-style-map" class="hidden">
+                        <div class="cm-style-grid" id="cm-style-grid"></div>
+                    </div>
+                    <div class="caller-model-row">
                         <label>
-                            Host
-                            <input type="text" id="ollama-host" value="http://localhost:11434">
+                            Fallback Model
+                            <select id="cm-fallback" class="model-select"></select>
                         </label>
-                        <button type="button" id="refresh-ollama" class="refresh-btn">Refresh Models</button>
                     </div>
                 </div>
 
@@ -171,8 +358,24 @@
                 </div>
             </div>
         </div>
+        <!-- Preflight Modal -->
+        <div id="preflight-modal" class="modal hidden">
+            <div class="modal-content preflight-content">
+                <h2>Show Preflight</h2>
+                <div id="preflight-status" class="preflight-status loading">
+                    <span class="preflight-status-icon">...</span>
+                    <span class="preflight-status-text">Running checks...</span>
+                </div>
+                <div id="preflight-checks" class="preflight-checks"></div>
+                <div class="modal-buttons">
+                    <button id="preflight-test-btn" class="preflight-test-btn">Test Responses</button>
+                    <button id="preflight-rerun-btn">Re-run</button>
+                    <button id="close-preflight">Close</button>
+                </div>
+            </div>
+        </div>
     </div>
 
-    <script src="/js/app.js?v=8"></script>
+    <script src="/js/app.js?v=27"></script>
 </body>
 </html>

functions/feed.js

@@ -0,0 +1,12 @@
+export async function onRequest() {
+  const feedUrl = 'https://podcast.macneilmediagroup.com/@LukeAtTheRoost/feed.xml';
+  const res = await fetch(feedUrl);
+  const xml = await res.text();
+  return new Response(xml, {
+    headers: {
+      'Content-Type': 'application/xml',
+      'Access-Control-Allow-Origin': '*',
+      'Cache-Control': 'public, max-age=300',
+    },
+  });
+}

make_social_post.py

@@ -0,0 +1,271 @@
+#!/usr/bin/env python3
+"""Generate social media announcement images for Luke at the Roost.
+
+Usage:
+    python make_social_post.py                           # regenerate with defaults
+    python make_social_post.py --title "NEW FEATURE"     # custom title
+    python make_social_post.py --body body_text.txt      # body from file
+
+Outputs square (1080x1080) and landscape (1200x675) PNGs to social_posts/.
+"""
+
+import argparse
+import os
+import textwrap
+from PIL import Image, ImageDraw, ImageFont, ImageOps
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+COVER = os.path.join(SCRIPT_DIR, "website/images/cover.png")
+OUT_DIR = os.path.join(SCRIPT_DIR, "social_posts")
+
+# Brand colors
+BG = (18, 13, 7)
+ACCENT = (232, 121, 29)
+WHITE = (255, 255, 255)
+MUTED = (175, 165, 150)
+LIGHTER = (220, 215, 205)
+
+# macOS system fonts — swap these on Linux/Windows
+FONT_BLACK = "/System/Library/Fonts/Supplemental/Arial Black.ttf"
+FONT_BOLD = "/System/Library/Fonts/Supplemental/Arial Bold.ttf"
+FONT_REG = "/System/Library/Fonts/Supplemental/Arial.ttf"
+
+
+def load_font(path, size):
+    return ImageFont.truetype(path, size)
+
+
+def text_bbox(draw, text, font):
+    bb = draw.textbbox((0, 0), text, font=font)
+    return bb[2] - bb[0], bb[3] - bb[1], bb[1]  # width, height, y_offset
+
+
+def wrap_text(draw, text, x, y, max_w, font, fill, line_gap=10,
+              cover_right=None, cover_bottom=None):
+    """Word-wrap text onto the image, narrowing lines that overlap the cover.
+
+    line_gap: fixed pixel gap between lines (not a multiplier).
+    Returns y just below the last line of text (no trailing gap)."""
+    words = text.split()
+    lines = []
+    cur = ""
+    cur_y = y
+
+    for word in words:
+        test = f"{cur} {word}".strip()
+        eff_w = max_w
+        if cover_right and cover_bottom and cur_y < cover_bottom:
+            eff_w = cover_right - x - 20
+
+        tw, th, _ = text_bbox(draw, test, font)
+        if tw > eff_w and cur:
+            lines.append((cur, cur_y))
+            _, lh, _ = text_bbox(draw, cur, font)
+            cur_y += lh + line_gap
+            cur = word
+        else:
+            cur = test
+
+    if cur:
+        lines.append((cur, cur_y))
+        _, lh, _ = text_bbox(draw, cur, font)
+
+    for line, ly in lines:
+        draw.text((x, ly), line, font=font, fill=fill)
+
+    return cur_y + lh  # return y just past the last line's bottom
+
+
+def center_text(draw, text, y, canvas_w, font, fill):
+    tw, th, _ = text_bbox(draw, text, font)
+    draw.text(((canvas_w - tw) // 2, y), text, font=font, fill=fill)
+    return y + th
+
+
+def draw_email_box(draw, email, y, canvas_w, font):
+    tw, th, y_off = text_bbox(draw, email, font)
+    px, py = 22, 16
+    box_w = tw + px * 2
+    box_x = (canvas_w - box_w) // 2
+    draw.rounded_rectangle(
+        [box_x, y, box_x + box_w, y + th + py * 2],
+        radius=8, fill=(45, 30, 12), outline=ACCENT, width=2,
+    )
+    draw.text((box_x + px, y + py - y_off), email, font=font, fill=ACCENT)
+    return y + th + py * 2
+
+
+def draw_accent_bars(draw, w, h, thickness):
+    draw.rectangle([0, 0, w, thickness], fill=ACCENT)
+    draw.rectangle([0, h - thickness, w, h], fill=ACCENT)
+
+
+def paste_cover(img, x, y, size, radius):
+    cover = Image.open(COVER).resize((size, size), Image.LANCZOS)
+    mask = Image.new("L", (size, size), 0)
+    ImageDraw.Draw(mask).rounded_rectangle([0, 0, size, size], radius=radius, fill=255)
+    img.paste(cover, (x, y), mask)
+
+
+def make_square(title, paragraphs, email, filename="email_announcement_square.png"):
+    W = 1080
+    img = Image.new("RGB", (W, W), BG)
+    draw = ImageDraw.Draw(img)
+    draw_accent_bars(draw, W, W, 8)
+
+    # Cover image — top right
+    cover_size, cover_x, cover_y = 240, W - 290, 35
+    paste_cover(img, cover_x, cover_y, cover_size, 20)
+    cover_bottom = cover_y + cover_size + 15
+
+    m = 60
+    y = 40
+    tw_full = W - m * 2
+
+    # Header
+    draw.text((m, y), "LUKE AT THE ROOST", font=load_font(FONT_BOLD, 24), fill=ACCENT)
+    y += 30
+    tag = load_font(FONT_REG, 20)
+    draw.text((m, y), "Late-night call-in radio", font=tag, fill=MUTED)
+    draw.text((m, y + 26), "powered by AI", font=tag, fill=MUTED)
+    y += 75
+
+    # Consistent spacing constants
+    LINE_GAP = 12       # between lines within a block
+    SECTION_GAP = 32    # between sections (body→CTA, CTA→footer)
+    PARA_GAP = 26       # between body paragraphs
+    TITLE_GAP = 48      # between title and first body paragraph
+
+    # Title
+    y = wrap_text(draw, title, m, y, tw_full, load_font(FONT_BLACK, 72), WHITE,
+                  line_gap=LINE_GAP, cover_right=cover_x, cover_bottom=cover_bottom)
+    y += TITLE_GAP
+
+    # Body paragraphs
+    body_font = load_font(FONT_REG, 32)
+    colors = [LIGHTER] + [MUTED] * (len(paragraphs) - 1)
+    for i, (para, color) in enumerate(zip(paragraphs, colors)):
+        cr = cover_x if y < cover_bottom else None
+        cb = cover_bottom if y < cover_bottom else None
+        y = wrap_text(draw, para, m, y, tw_full, body_font, color,
+                      line_gap=LINE_GAP, cover_right=cr, cover_bottom=cb)
+        if i < len(paragraphs) - 1:
+            y += PARA_GAP
+
+    y += SECTION_GAP
+
+    # Email CTA
+    y = draw_email_box(draw, email, y, W, load_font(FONT_BOLD, 36))
+    y += SECTION_GAP
+
+    # Footer
+    y = center_text(draw, "New episodes drop daily. Be part of the next one.",
+                    y, W, load_font(FONT_REG, 24), MUTED)
+    y += PARA_GAP
+    info = load_font(FONT_REG, 22)
+    center_text(draw, "lukeattheroost.com", y, W, info, ACCENT)
+    y += PARA_GAP
+    center_text(draw, "Spotify  \u00b7  Apple Podcasts  \u00b7  YouTube  \u00b7  RSS",
+                y, W, info, MUTED)
+
+    os.makedirs(OUT_DIR, exist_ok=True)
+    img.save(os.path.join(OUT_DIR, filename), quality=95)
+    print(f"Square: {filename}")
+
+
+def make_landscape(title, paragraphs, email, filename="email_announcement_twitter.png"):
+    TW, TH = 1200, 675
+    img = Image.new("RGB", (TW, TH), BG)
+    draw = ImageDraw.Draw(img)
+    draw_accent_bars(draw, TW, TH, 6)
+
+    # Cover image — top right
+    cover_size, cover_x, cover_y = 180, TW - 220, 22
+    paste_cover(img, cover_x, cover_y, cover_size, 16)
+    cover_bottom = cover_y + cover_size + 10
+
+    m = 45
+    y = 25
+    tw_full = TW - m * 2
+
+    # Header
+    draw.text((m, y), "LUKE AT THE ROOST", font=load_font(FONT_BOLD, 20), fill=ACCENT)
+    y += 24
+    draw.text((m, y), "Late-night call-in radio powered by AI",
+              font=load_font(FONT_REG, 17), fill=MUTED)
+    y += 38
+
+    # Consistent spacing constants
+    LINE_GAP = 8        # between lines within a block
+    SECTION_GAP = 20    # between sections
+    PARA_GAP = 16       # between body paragraphs
+    TITLE_GAP = 32      # between title and first body paragraph
+
+    # Title
+    y = wrap_text(draw, title, m, y, tw_full, load_font(FONT_BLACK, 50), WHITE,
+                  line_gap=LINE_GAP, cover_right=cover_x, cover_bottom=cover_bottom)
+    y += TITLE_GAP
+
+    # Body paragraphs
+    body_font = load_font(FONT_REG, 23)
+    colors = [LIGHTER] + [MUTED] * (len(paragraphs) - 1)
+    for i, (para, color) in enumerate(zip(paragraphs, colors)):
+        cr = cover_x if y < cover_bottom else None
+        cb = cover_bottom if y < cover_bottom else None
+        y = wrap_text(draw, para, m, y, tw_full, body_font, color,
+                      line_gap=LINE_GAP, cover_right=cr, cover_bottom=cb)
+        if i < len(paragraphs) - 1:
+            y += PARA_GAP
+
+    y += SECTION_GAP
+
+    # Email CTA
+    y = draw_email_box(draw, email, y, TW, load_font(FONT_BOLD, 26))
+    y += SECTION_GAP
+
+    # Footer
+    y = center_text(draw, "New episodes drop daily. Be part of the next one.",
+                    y, TW, load_font(FONT_REG, 19), MUTED)
+    y += PARA_GAP
+    center_text(draw, "lukeattheroost.com  \u00b7  Spotify  \u00b7  Apple Podcasts  \u00b7  YouTube",
+                y, TW, load_font(FONT_REG, 17), (140, 132, 120))
+
+    os.makedirs(OUT_DIR, exist_ok=True)
+    img.save(os.path.join(OUT_DIR, filename), quality=95)
+    print(f"Landscape: {filename}")
+
+
+# --- Default content ---
+
+DEFAULT_TITLE = "NOW ACCEPTING LISTENER EMAILS"
+DEFAULT_EMAIL = "submissions@lukeattheroost.com"
+DEFAULT_PARAGRAPHS = [
+    "Got a story? A question? A hot take that\u2019s been eating at you since midnight? A confession you need to get off your chest? Send it to the show.",
+    "The best listener emails get read live on air during the next episode \u2014 either by Luke himself on the mic, or by one of his robot friends. Your words, on the show, heard by everyone tuning in.",
+    "Can\u2019t call 208-439-LUKE at 2 AM? Don\u2019t want to talk on the phone? Now you\u2019ve got another way to be part of the conversation. Write in anytime \u2014 day or night, long or short, serious or unhinged.",
+]
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Generate social media images")
+    parser.add_argument("--title", default=DEFAULT_TITLE)
+    parser.add_argument("--email", default=DEFAULT_EMAIL)
+    parser.add_argument("--body", help="Text file with paragraphs (blank-line separated)")
+    parser.add_argument("--prefix", default="email_announcement",
+                        help="Output filename prefix")
+    args = parser.parse_args()
+
+    if args.body:
+        with open(args.body) as f:
+            paragraphs = [p.strip() for p in f.read().split("\n\n") if p.strip()]
+    else:
+        paragraphs = DEFAULT_PARAGRAPHS
+
+    make_square(args.title, paragraphs, args.email,
+                filename=f"{args.prefix}_square.png")
+    make_landscape(args.title, paragraphs, args.email,
+                   filename=f"{args.prefix}_twitter.png")
+
+
+if __name__ == "__main__":
+    main()

podcast_stats.py

@@ -0,0 +1,441 @@
+#!/usr/bin/env python3
+"""
+Podcast Stats — Aggregate reviews, comments, likes, and analytics from all platforms.
+
+Usage:
+    python podcast_stats.py              # All platforms
+    python podcast_stats.py --youtube    # YouTube only
+    python podcast_stats.py --apple      # Apple Podcasts only
+    python podcast_stats.py --spotify    # Spotify only
+    python podcast_stats.py --castopod   # Castopod downloads only
+    python podcast_stats.py --comments   # Include full YouTube comments
+    python podcast_stats.py --json       # Output as JSON
+    python podcast_stats.py --json --upload  # Output JSON and upload to BunnyCDN
+"""
+
+import argparse
+import json
+import os
+import re
+import subprocess
+import sys
+from datetime import datetime, timezone
+
+import requests
+from dotenv import load_dotenv
+load_dotenv(os.path.join(os.path.dirname(os.path.abspath(__file__)), ".env"))
+
+YOUTUBE_PLAYLIST = "PLGq4uZyNV1yYH_rcitTTPVysPbC6-7pe-"
+APPLE_PODCAST_ID = "1875205848"
+APPLE_STOREFRONTS = ["us", "gb", "ca", "au"]
+SPOTIFY_SHOW_ID = "0ZrpMigG1fo0CCN7F4YmuF"
+NAS_SSH = "luke@mmgnas-10g"
+NAS_SSH_PORT = "8001"
+DOCKER_BIN = "/share/CACHEDEV1_DATA/.qpkg/container-station/bin/docker"
+CASTOPOD_DB_CONTAINER = "castopod-mariadb-1"
+
+BUNNY_STORAGE_ZONE = "lukeattheroost"
+BUNNY_STORAGE_KEY = os.getenv("BUNNY_STORAGE_KEY", "")
+BUNNY_STORAGE_REGION = "la"
+BUNNY_ACCOUNT_KEY = os.getenv("BUNNY_ACCOUNT_KEY", "")
+
+
+def _find_ytdlp():
+    """Find yt-dlp: check local venv first, then fall back to PATH."""
+    import shutil
+    venv_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "venv", "bin", "yt-dlp")
+    if os.path.exists(venv_path):
+        return venv_path
+    path_bin = shutil.which("yt-dlp")
+    if path_bin:
+        return path_bin
+    return "yt-dlp"
+
+
+def gather_apple_reviews():
+    all_reviews = []
+    seen_ids = set()
+
+    for storefront in APPLE_STOREFRONTS:
+        url = f"https://itunes.apple.com/{storefront}/rss/customerreviews/id={APPLE_PODCAST_ID}/sortby=mostrecent/json"
+        try:
+            resp = requests.get(url, timeout=15)
+            if resp.status_code != 200:
+                continue
+            data = resp.json()
+        except Exception:
+            continue
+
+        feed = data.get("feed", {})
+        entries = feed.get("entry", [])
+        if not entries:
+            continue
+
+        for entry in entries:
+            if "im:name" in entry and "im:rating" not in entry:
+                continue
+
+            review_id = entry.get("id", {}).get("label", "")
+            if review_id in seen_ids:
+                continue
+            seen_ids.add(review_id)
+
+            author = entry.get("author", {}).get("name", {}).get("label", "Unknown")
+            title = entry.get("title", {}).get("label", "")
+            content = entry.get("content", {}).get("label", "")
+            rating = int(entry.get("im:rating", {}).get("label", "0"))
+            updated = entry.get("updated", {}).get("label", "")
+            date_str = updated[:10] if updated else ""
+
+            all_reviews.append({
+                "author": author,
+                "title": title,
+                "content": content,
+                "rating": rating,
+                "date": date_str,
+                "storefront": storefront.upper(),
+            })
+
+    avg_rating = round(sum(r["rating"] for r in all_reviews) / len(all_reviews), 1) if all_reviews else None
+    return {
+        "avg_rating": avg_rating,
+        "review_count": len(all_reviews),
+        "reviews": all_reviews[:10],
+    }
+
+
+def gather_spotify():
+    result = {"show_title": None, "rating": None, "url": f"https://open.spotify.com/show/{SPOTIFY_SHOW_ID}"}
+
+    try:
+        oembed_url = f"https://open.spotify.com/oembed?url=https://open.spotify.com/show/{SPOTIFY_SHOW_ID}"
+        resp = requests.get(oembed_url, timeout=15)
+        if resp.status_code == 200:
+            data = resp.json()
+            result["show_title"] = data.get("title")
+
+        show_url = f"https://open.spotify.com/show/{SPOTIFY_SHOW_ID}"
+        resp = requests.get(show_url, timeout=15, headers={
+            "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7)"
+        })
+
+        rating_match = re.search(r'"ratingValue"\s*:\s*"?([\d.]+)"?', resp.text)
+        if rating_match:
+            result["rating"] = float(rating_match.group(1))
+        else:
+            rating_match2 = re.search(r'rating["\s:]*(\d+\.?\d*)\s*/\s*5', resp.text, re.IGNORECASE)
+            if rating_match2:
+                result["rating"] = float(rating_match2.group(1))
+    except Exception:
+        pass
+
+    return result
+
+
+def gather_youtube(include_comments=False):
+    result = {
+        "total_views": 0,
+        "total_likes": 0,
+        "total_comments": 0,
+        "subscribers": None,
+        "videos": [],
+    }
+
+    try:
+        proc = subprocess.run(
+            [_find_ytdlp(), "--dump-json", "--flat-playlist",
+             f"https://www.youtube.com/playlist?list={YOUTUBE_PLAYLIST}"],
+            capture_output=True, text=True, timeout=60
+        )
+        if proc.returncode != 0:
+            return result
+    except (FileNotFoundError, subprocess.TimeoutExpired):
+        return result
+
+    video_ids = []
+    for line in proc.stdout.strip().split("\n"):
+        if not line:
+            continue
+        try:
+            entry = json.loads(line)
+            vid = entry.get("id") or entry.get("url", "").split("=")[-1]
+            if vid:
+                video_ids.append(vid)
+        except json.JSONDecodeError:
+            continue
+
+    if not video_ids:
+        return result
+
+    total_views = 0
+    total_likes = 0
+    total_comments = 0
+    videos = []
+
+    for vid in video_ids:
+        try:
+            cmd = [_find_ytdlp(), "--dump-json", "--no-download", f"https://www.youtube.com/watch?v={vid}"]
+            if include_comments:
+                cmd.insert(2, "--write-comments")
+            vr = subprocess.run(cmd, capture_output=True, text=True, timeout=90)
+            if vr.returncode != 0:
+                continue
+            vdata = json.loads(vr.stdout)
+
+            title = vdata.get("title", "Unknown")
+            views = vdata.get("view_count", 0) or 0
+            likes = vdata.get("like_count", 0) or 0
+            comment_count = vdata.get("comment_count", 0) or 0
+            upload_date = vdata.get("upload_date", "")
+            if upload_date:
+                upload_date = f"{upload_date[:4]}-{upload_date[4:6]}-{upload_date[6:]}"
+
+            comments_list = []
+            if include_comments:
+                for c in (vdata.get("comments") or [])[:5]:
+                    comments_list.append({
+                        "author": c.get("author", "Unknown"),
+                        "text": c.get("text", "")[:200],
+                        "time": c.get("time_text", ""),
+                        "likes": c.get("like_count", 0),
+                    })
+
+            total_views += views
+            total_likes += likes
+            total_comments += comment_count
+
+            videos.append({
+                "title": title,
+                "views": views,
+                "likes": likes,
+                "comments": comment_count,
+                "date": upload_date,
+            })
+        except (subprocess.TimeoutExpired, json.JSONDecodeError):
+            continue
+
+    # Get subscriber count
+    if videos:
+        try:
+            vr = subprocess.run(
+                [_find_ytdlp(), "--dump-json", "--no-download", "--playlist-items", "1",
+                 f"https://www.youtube.com/playlist?list={YOUTUBE_PLAYLIST}"],
+                capture_output=True, text=True, timeout=30
+            )
+            if vr.returncode == 0:
+                ch_data = json.loads(vr.stdout)
+                sub = ch_data.get("channel_follower_count")
+                if sub is not None:
+                    result["subscribers"] = sub
+        except Exception:
+            pass
+
+    result["total_views"] = total_views
+    result["total_likes"] = total_likes
+    result["total_comments"] = total_comments
+    result["videos"] = videos
+    return result
+
+
+def _run_db_query(sql):
+    # If running on NAS (docker socket available), exec directly
+    docker_bin = None
+    for path in [DOCKER_BIN, "/usr/bin/docker", "/usr/local/bin/docker"]:
+        if os.path.exists(path):
+            docker_bin = path
+            break
+
+    db_pass = os.getenv("CASTOPOD_DB_PASS", "")
+    if docker_bin:
+        # Pass password via MYSQL_PWD env var instead of command line (not visible in ps)
+        cmd = [docker_bin, "exec", "-i", "-e", f"MYSQL_PWD={db_pass}",
+               CASTOPOD_DB_CONTAINER,
+               "mysql", "-u", "castopod", "castopod", "-N"]
+    else:
+        cmd = [
+            "ssh", "-p", NAS_SSH_PORT, NAS_SSH,
+            f"{DOCKER_BIN} exec -i -e MYSQL_PWD={db_pass} {CASTOPOD_DB_CONTAINER} mysql -u castopod castopod -N"
+        ]
+    try:
+        proc = subprocess.run(cmd, input=sql, capture_output=True, text=True, timeout=30)
+        stderr = proc.stderr.strip()
+        stdout = proc.stdout.strip()
+        if proc.returncode != 0 and not stdout:
+            return None, stderr
+        return stdout, None
+    except subprocess.TimeoutExpired:
+        return None, "timeout"
+    except Exception as e:
+        return None, str(e)
+
+
+def gather_castopod():
+    result = {"total_downloads": 0, "unique_listeners": 0, "episodes": []}
+
+    query = (
+        "SELECT p.title, "
+        "(SELECT SUM(hits) FROM cp_analytics_podcasts WHERE podcast_id = p.id), "
+        "(SELECT SUM(unique_listeners) FROM cp_analytics_podcasts WHERE podcast_id = p.id) "
+        "FROM cp_podcasts p WHERE p.handle = 'LukeAtTheRoost' LIMIT 1;"
+    )
+    episode_query = (
+        "SELECT e.title, e.slug, COALESCE(SUM(ae.hits), 0), e.published_at "
+        "FROM cp_episodes e LEFT JOIN cp_analytics_podcasts_by_episode ae ON ae.episode_id = e.id "
+        "WHERE e.podcast_id = (SELECT id FROM cp_podcasts WHERE handle = 'LukeAtTheRoost') "
+        "GROUP BY e.id ORDER BY e.published_at DESC;"
+    )
+
+    out, err = _run_db_query(query)
+    if err or not out:
+        return result
+
+    parts = out.split("\t")
+    if len(parts) >= 3:
+        result["total_downloads"] = int(parts[1]) if parts[1] and parts[1] != "NULL" else 0
+        result["unique_listeners"] = int(parts[2]) if parts[2] and parts[2] != "NULL" else 0
+    elif len(parts) >= 2:
+        result["total_downloads"] = int(parts[1]) if parts[1] and parts[1] != "NULL" else 0
+
+    out, err = _run_db_query(episode_query)
+    if err or not out:
+        return result
+
+    for line in out.strip().split("\n"):
+        cols = line.split("\t")
+        if len(cols) >= 4:
+            result["episodes"].append({
+                "title": cols[0],
+                "downloads": int(cols[2]) if cols[2] else 0,
+                "date": cols[3][:10] if cols[3] else "",
+            })
+
+    return result
+
+
+def print_apple(data):
+    print("\n⭐ APPLE PODCASTS")
+    print("─" * 40)
+    if data["reviews"]:
+        print(f"  Rating: {data['avg_rating']}/5 ({data['review_count']} reviews)")
+        print()
+        for r in data["reviews"]:
+            stars = "★" * r["rating"] + "☆" * (5 - r["rating"])
+            print(f"  {stars} \"{r['title']}\" — {r['author']} ({r['date']}, {r['storefront']})")
+            if r["content"] and r["content"] != r["title"]:
+                content_preview = r["content"][:120]
+                if len(r["content"]) > 120:
+                    content_preview += "..."
+                print(f"    {content_preview}")
+    else:
+        print("  No reviews found")
+
+
+def print_spotify(data):
+    print("\n🎵 SPOTIFY")
+    print("─" * 40)
+    if data["show_title"]:
+        print(f"  Show: {data['show_title']}")
+    if data["rating"]:
+        print(f"  Rating: {data['rating']}/5")
+    else:
+        print("  Rating: Not publicly available (Spotify hides ratings from web)")
+    print(f"  Link: {data['url']}")
+
+
+def print_youtube(data):
+    print("\n📺 YOUTUBE")
+    print("─" * 40)
+    sub_str = f" | Subscribers: {data['subscribers']:,}" if data["subscribers"] else ""
+    print(f"  Total views: {data['total_views']:,} | Likes: {data['total_likes']:,} | Comments: {data['total_comments']:,}{sub_str}")
+    print()
+    for v in data["videos"]:
+        print(f"  {v['title']}")
+        print(f"    {v['views']:,} views, {v['likes']:,} likes, {v['comments']:,} comments — {v['date']}")
+
+
+def print_castopod(data):
+    print("\n📊 DOWNLOADS (Castopod)")
+    print("─" * 40)
+    print(f"  Total downloads: {data['total_downloads']:,} | Unique listeners: {data['unique_listeners']:,}")
+    if data["episodes"]:
+        print()
+        for ep in data["episodes"]:
+            print(f"  {ep['title']} — {ep['downloads']:,} downloads ({ep['date']})")
+
+
+def upload_to_bunnycdn(json_data):
+    storage_url = f"https://{BUNNY_STORAGE_REGION}.storage.bunnycdn.com/{BUNNY_STORAGE_ZONE}/stats.json"
+    resp = requests.put(
+        storage_url,
+        data=json_data,
+        headers={
+            "AccessKey": BUNNY_STORAGE_KEY,
+            "Content-Type": "application/json",
+        },
+        timeout=30,
+    )
+    resp.raise_for_status()
+
+    purge_url = "https://api.bunny.net/purge"
+    requests.post(
+        purge_url,
+        params={"url": "https://cdn.lukeattheroost.com/stats.json"},
+        headers={"AccessKey": BUNNY_ACCOUNT_KEY},
+        timeout=15,
+    )
+    print("Uploaded stats.json to BunnyCDN and purged cache", file=sys.stderr)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Podcast analytics aggregator")
+    parser.add_argument("--youtube", action="store_true", help="YouTube only")
+    parser.add_argument("--apple", action="store_true", help="Apple Podcasts only")
+    parser.add_argument("--spotify", action="store_true", help="Spotify only")
+    parser.add_argument("--castopod", action="store_true", help="Castopod only")
+    parser.add_argument("--comments", action="store_true", help="Include YouTube comments")
+    parser.add_argument("--json", dest="json_output", action="store_true", help="Output as JSON")
+    parser.add_argument("--upload", action="store_true", help="Upload JSON to BunnyCDN (requires --json)")
+    args = parser.parse_args()
+
+    if args.upload and not args.json_output:
+        print("Error: --upload requires --json", file=sys.stderr)
+        sys.exit(1)
+
+    run_all = not (args.youtube or args.apple or args.spotify or args.castopod)
+
+    results = {}
+    if run_all or args.castopod:
+        results["castopod"] = gather_castopod()
+    if run_all or args.apple:
+        results["apple"] = gather_apple_reviews()
+    if run_all or args.spotify:
+        results["spotify"] = gather_spotify()
+    if run_all or args.youtube:
+        results["youtube"] = gather_youtube(include_comments=args.comments or args.youtube)
+
+    if args.json_output:
+        output = {
+            "updated_at": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
+            **results,
+        }
+        json_str = json.dumps(output, indent=2, ensure_ascii=False)
+        print(json_str)
+        if args.upload:
+            upload_to_bunnycdn(json_str)
+    else:
+        print("=" * 45)
+        print("  PODCAST STATS: Luke at the Roost")
+        print("=" * 45)
+        if "castopod" in results:
+            print_castopod(results["castopod"])
+        if "apple" in results:
+            print_apple(results["apple"])
+        if "spotify" in results:
+            print_spotify(results["spotify"])
+        if "youtube" in results:
+            print_youtube(results["youtube"])
+        print()
+
+
+if __name__ == "__main__":
+    main()

postprod.py

@@ -0,0 +1,920 @@
+#!/usr/bin/env python3
+"""Post-production pipeline for AI podcast stems.
+
+Usage: python postprod.py recordings/2026-02-07_213000/ -o episode.mp3
+
+Processes 6 aligned WAV stems (host, caller, music, sfx, ads, idents) into a
+broadcast-ready MP3 with gap removal, voice compression, music ducking,
+and loudness normalization.
+"""
+
+import argparse
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+import numpy as np
+import soundfile as sf
+
+STEM_NAMES = ["host", "caller", "devon", "music", "sfx", "ads", "idents"]
+
+
+def load_stems(stems_dir: Path) -> tuple[dict[str, np.ndarray], int]:
+    stems = {}
+    sample_rate = None
+    for name in STEM_NAMES:
+        path = stems_dir / f"{name}.wav"
+        if not path.exists():
+            print(f"  {name}.wav not found, creating empty stem")
+            stems[name] = None
+            continue
+        data, sr = sf.read(str(path), dtype="float32")
+        if sample_rate is None:
+            sample_rate = sr
+        elif sr != sample_rate:
+            print(f"  WARNING: {name}.wav has sample rate {sr}, expected {sample_rate}")
+        stems[name] = data
+        print(f"  {name}: {len(data)} samples ({len(data)/sr:.1f}s)")
+
+    if sample_rate is None:
+        print("ERROR: No valid stems found")
+        sys.exit(1)
+
+    # Pad all stems to same length
+    max_len = max(len(s) for s in stems.values() if s is not None)
+    for name in STEM_NAMES:
+        if stems[name] is None:
+            stems[name] = np.zeros(max_len, dtype=np.float32)
+        elif len(stems[name]) < max_len:
+            stems[name] = np.pad(stems[name], (0, max_len - len(stems[name])))
+
+    return stems, sample_rate
+
+
+def compute_rms(audio: np.ndarray, window_samples: int) -> np.ndarray:
+    n_windows = len(audio) // window_samples
+    if n_windows == 0:
+        return np.array([0.0])
+    trimmed = audio[:n_windows * window_samples].reshape(n_windows, window_samples)
+    return np.sqrt(np.mean(trimmed ** 2, axis=1))
+
+
+def remove_gaps(stems: dict[str, np.ndarray], sr: int,
+                threshold_s: float = 2.0, max_gap_s: float = 15.0,
+                crossfade_ms: float = 30, pad_s: float = 0.5) -> dict[str, np.ndarray]:
+    window_ms = 50
+    window_samples = int(sr * window_ms / 1000)
+    crossfade_samples = int(sr * crossfade_ms / 1000)
+
+    # Detect gaps in everything except music (which always plays).
+    # This catches TTS latency gaps while protecting ad breaks and SFX transitions.
+    content = stems["host"] + stems["caller"] + stems["devon"] + stems["sfx"] + stems["ads"] + stems["idents"]
+    rms = compute_rms(content, window_samples)
+
+    # Threshold: percentile-based to sit above the mic noise floor
+    nonzero_rms = rms[rms > 0]
+    if len(nonzero_rms) == 0:
+        print("  No audio detected")
+        return stems
+    noise_floor = np.percentile(nonzero_rms, 20)
+    silence_thresh = noise_floor * 3
+
+    is_silent = rms < silence_thresh
+    min_silent_windows = int(threshold_s / (window_ms / 1000))
+    max_silent_windows = int(max_gap_s / (window_ms / 1000))
+
+    # Only cut gaps between threshold-8s — targets TTS latency, not long breaks
+    cuts = []
+    i = 0
+    while i < len(is_silent):
+        if is_silent[i]:
+            start = i
+            while i < len(is_silent) and is_silent[i]:
+                i += 1
+            length = i - start
+            if min_silent_windows <= length <= max_silent_windows:
+                # Leave pad_s of silence so the edit sounds natural
+                pad_samples = int(pad_s * sr)
+                cut_start = (start + 1) * window_samples + pad_samples
+                cut_end = (i - 1) * window_samples - pad_samples
+                if cut_end > cut_start + crossfade_samples * 2:
+                    cuts.append((cut_start, cut_end))
+        else:
+            i += 1
+
+    if not cuts:
+        print("  No gaps to remove")
+        return stems
+
+    total_cut = sum(end - start for start, end in cuts) / sr
+    print(f"  Removing {len(cuts)} gaps ({total_cut:.1f}s total)")
+
+    # Cut dialog/sfx/ads at gap points. Leave music uncut — just trim to fit.
+    result = {}
+
+    for name in STEM_NAMES:
+        if name == "music":
+            continue  # handled below
+        audio = stems[name]
+        pieces = []
+        prev_end = 0
+        for cut_start, cut_end in cuts:
+            if prev_end < cut_start:
+                piece = audio[prev_end:cut_start].copy()
+                if pieces and len(piece) > crossfade_samples:
+                    fade_in = np.linspace(0, 1, crossfade_samples, dtype=np.float32)
+                    piece[:crossfade_samples] *= fade_in
+                if len(pieces) > 0 and len(pieces[-1]) > crossfade_samples:
+                    fade_out = np.linspace(1, 0, crossfade_samples, dtype=np.float32)
+                    pieces[-1][-crossfade_samples:] *= fade_out
+                pieces.append(piece)
+            prev_end = cut_end
+
+        if prev_end < len(audio):
+            piece = audio[prev_end:].copy()
+            if pieces and len(piece) > crossfade_samples:
+                fade_in = np.linspace(0, 1, crossfade_samples, dtype=np.float32)
+                piece[:crossfade_samples] *= fade_in
+            if len(pieces) > 0 and len(pieces[-1]) > crossfade_samples:
+                fade_out = np.linspace(1, 0, crossfade_samples, dtype=np.float32)
+                pieces[-1][-crossfade_samples:] *= fade_out
+            pieces.append(piece)
+
+        result[name] = np.concatenate(pieces) if pieces else np.array([], dtype=np.float32)
+
+    # Music: leave uncut, just trim to match new duration with fade-out
+    new_len = len(result["host"])
+    music = stems["music"]
+    if len(music) >= new_len:
+        music = music[:new_len].copy()
+    else:
+        music = np.pad(music, (0, new_len - len(music)))
+    fade_samples = int(sr * 3)
+    if len(music) > fade_samples:
+        music[-fade_samples:] *= np.linspace(1, 0, fade_samples, dtype=np.float32)
+    result["music"] = music
+
+    return result
+
+
+def denoise(audio: np.ndarray, sr: int, tmp_dir: Path) -> np.ndarray:
+    """HPF to cut rumble below 80Hz (plosives, HVAC, handling noise)."""
+    in_path = tmp_dir / "host_pre_denoise.wav"
+    out_path = tmp_dir / "host_post_denoise.wav"
+    sf.write(str(in_path), audio, sr)
+
+    af = "highpass=f=80:poles=2"
+    cmd = ["ffmpeg", "-y", "-i", str(in_path), "-af", af, str(out_path)]
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    if result.returncode != 0:
+        print(f"  WARNING: denoise failed: {result.stderr[:200]}")
+        return audio
+
+    denoised, _ = sf.read(str(out_path), dtype="float32")
+    return denoised
+
+
+def deess(audio: np.ndarray, sr: int, tmp_dir: Path) -> np.ndarray:
+    """Reduce sibilance (harsh s/sh/ch sounds) in voice audio."""
+    in_path = tmp_dir / "host_pre_deess.wav"
+    out_path = tmp_dir / "host_post_deess.wav"
+    sf.write(str(in_path), audio, sr)
+
+    # Gentle high-shelf reduction at 5kHz (-4dB) to tame sibilance
+    # Single-pass, no phase issues unlike split-band approaches
+    af = "equalizer=f=5500:t=h:w=2000:g=-4"
+    cmd = ["ffmpeg", "-y", "-i", str(in_path), "-af", af, str(out_path)]
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    if result.returncode != 0:
+        print(f"  WARNING: de-essing failed: {result.stderr[:200]}")
+        return audio
+
+    deessed, _ = sf.read(str(out_path), dtype="float32")
+    return deessed
+
+
+def reduce_breaths(audio: np.ndarray, sr: int, reduction_db: float = -12) -> np.ndarray:
+    """Reduce loud breaths between speech phrases."""
+    window_ms = 30
+    window_samples = int(sr * window_ms / 1000)
+    rms = compute_rms(audio, window_samples)
+
+    if not np.any(rms > 0):
+        return audio
+
+    # Speech threshold: breaths are quieter than speech but louder than silence
+    nonzero = rms[rms > 0]
+    speech_level = np.percentile(nonzero, 70)
+    silence_level = np.percentile(nonzero, 10)
+    breath_upper = speech_level * 0.3  # below 30% of speech level
+    breath_lower = silence_level * 2   # above 2x silence
+
+    if breath_upper <= breath_lower:
+        return audio
+
+    # Detect breath-length bursts (0.15-0.8s) in the breath amplitude range
+    min_windows = int(150 / window_ms)
+    max_windows = int(800 / window_ms)
+
+    breath_gain = 10 ** (reduction_db / 20)
+    gain_envelope = np.ones(len(rms), dtype=np.float32)
+
+    i = 0
+    breath_count = 0
+    while i < len(rms):
+        if breath_lower < rms[i] < breath_upper:
+            start = i
+            while i < len(rms) and breath_lower < rms[i] < breath_upper:
+                i += 1
+            length = i - start
+            if min_windows <= length <= max_windows:
+                gain_envelope[start:i] = breath_gain
+                breath_count += 1
+        else:
+            i += 1
+
+    if breath_count == 0:
+        return audio
+
+    print(f"  Reduced {breath_count} breaths by {reduction_db}dB")
+
+    # Smooth transitions (10ms ramp)
+    ramp = max(1, int(10 / window_ms))
+    smoothed = gain_envelope.copy()
+    for i in range(1, len(smoothed)):
+        if smoothed[i] < smoothed[i - 1]:
+            smoothed[i] = smoothed[i - 1] + (smoothed[i] - smoothed[i - 1]) / ramp
+        elif smoothed[i] > smoothed[i - 1]:
+            smoothed[i] = smoothed[i - 1] + (smoothed[i] - smoothed[i - 1]) / ramp
+
+    # Expand to sample level
+    gain_samples = np.repeat(smoothed, window_samples)[:len(audio)]
+    if len(gain_samples) < len(audio):
+        gain_samples = np.pad(gain_samples, (0, len(audio) - len(gain_samples)), constant_values=1.0)
+
+    return (audio * gain_samples).astype(np.float32)
+
+
+def limit_stem(audio: np.ndarray, sr: int, tmp_dir: Path,
+               stem_name: str) -> np.ndarray:
+    """Hard-limit a stem to -1dB true peak to prevent clipping."""
+    peak = np.max(np.abs(audio))
+    if peak <= 0.89:  # already below -1dB
+        return audio
+    in_path = tmp_dir / f"{stem_name}_pre_limit.wav"
+    out_path = tmp_dir / f"{stem_name}_post_limit.wav"
+    sf.write(str(in_path), audio, sr)
+    cmd = [
+        "ffmpeg", "-y", "-i", str(in_path),
+        "-af", "alimiter=limit=-1dB:level=false:attack=0.1:release=50",
+        str(out_path),
+    ]
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    if result.returncode != 0:
+        print(f"  WARNING: limiting failed for {stem_name}: {result.stderr[:200]}")
+        return audio
+    limited, _ = sf.read(str(out_path), dtype="float32")
+    peak_db = 20 * np.log10(peak)
+    print(f"  {stem_name}: peak was {peak_db:+.1f}dB, limited to -1dB")
+    return limited
+
+
+def compress_voice(audio: np.ndarray, sr: int, tmp_dir: Path,
+                   stem_name: str) -> np.ndarray:
+    in_path = tmp_dir / f"{stem_name}_pre_comp.wav"
+    out_path = tmp_dir / f"{stem_name}_post_comp.wav"
+
+    sf.write(str(in_path), audio, sr)
+
+    if stem_name == "host":
+        # Spoken word compression: lower threshold, higher ratio, more makeup
+        af = "acompressor=threshold=-28dB:ratio=4:attack=5:release=600:makeup=8dB"
+    else:
+        af = "acompressor=threshold=-24dB:ratio=2.5:attack=10:release=800:makeup=6dB"
+
+    cmd = [
+        "ffmpeg", "-y", "-i", str(in_path),
+        "-af", af,
+        str(out_path),
+    ]
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    if result.returncode != 0:
+        print(f"  WARNING: compression failed for {stem_name}: {result.stderr[:200]}")
+        return audio
+
+    compressed, _ = sf.read(str(out_path), dtype="float32")
+    return compressed
+
+
+def phone_eq(audio: np.ndarray, sr: int, tmp_dir: Path) -> np.ndarray:
+    """Apply telephone EQ to make caller sound like a phone call."""
+    in_path = tmp_dir / "caller_pre_phone.wav"
+    out_path = tmp_dir / "caller_post_phone.wav"
+    sf.write(str(in_path), audio, sr)
+
+    # Bandpass 300-3400Hz (telephone bandwidth) + slight mid boost for presence
+    af = (
+        "highpass=f=300:poles=2,"
+        "lowpass=f=3400:poles=2,"
+        "equalizer=f=1000:t=q:w=0.8:g=4"
+    )
+    cmd = ["ffmpeg", "-y", "-i", str(in_path), "-af", af, str(out_path)]
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    if result.returncode != 0:
+        print(f"  WARNING: phone EQ failed: {result.stderr[:200]}")
+        return audio
+
+    filtered, _ = sf.read(str(out_path), dtype="float32")
+    return filtered
+
+
+def apply_ducking(music: np.ndarray, dialog: np.ndarray, sr: int,
+                  duck_db: float = -20, attack_ms: float = 200,
+                  release_ms: float = 3000,
+                  mute_signal: np.ndarray | None = None) -> np.ndarray:
+    window_ms = 50
+    window_samples = int(sr * window_ms / 1000)
+    rms = compute_rms(dialog, window_samples)
+
+    # Speech detection threshold
+    mean_rms = np.mean(rms[rms > 0]) if np.any(rms > 0) else 1e-4
+    speech_thresh = mean_rms * 0.1
+
+    # Build gain envelope (per window)
+    duck_gain = 10 ** (duck_db / 20)
+    is_speech = rms > speech_thresh
+    target_gain = np.where(is_speech, duck_gain, 1.0).astype(np.float32)
+
+    # Mute music completely during ads with lookahead and tail
+    if mute_signal is not None:
+        mute_rms = compute_rms(mute_signal, window_samples)
+        mute_thresh = np.mean(mute_rms[mute_rms > 0]) * 0.1 if np.any(mute_rms > 0) else 1e-4
+        is_ads = mute_rms > mute_thresh
+        # Expand ad regions: 2s before (fade out music before ad) and 2s after (don't resume immediately)
+        lookahead_windows = int(2000 / window_ms)
+        tail_windows = int(2000 / window_ms)
+        expanded_ads = is_ads.copy()
+        for i in range(len(is_ads)):
+            if is_ads[i]:
+                start = max(0, i - lookahead_windows)
+                end = min(len(expanded_ads), i + tail_windows + 1)
+                expanded_ads[start:end] = True
+        target_gain[expanded_ads] = 0.0
+
+    # Smooth the envelope
+    attack_windows = max(1, int(attack_ms / window_ms))
+    release_windows = max(1, int(release_ms / window_ms))
+    smoothed = np.ones_like(target_gain)
+    for i in range(1, len(target_gain)):
+        if target_gain[i] < smoothed[i - 1]:
+            alpha = 1.0 / attack_windows
+            smoothed[i] = smoothed[i - 1] + alpha * (target_gain[i] - smoothed[i - 1])
+        else:
+            alpha = 1.0 / release_windows
+            smoothed[i] = smoothed[i - 1] + alpha * (target_gain[i] - smoothed[i - 1])
+
+    # Expand envelope to sample level
+    gain_samples = np.repeat(smoothed, window_samples)
+    if len(gain_samples) < len(music):
+        gain_samples = np.pad(gain_samples, (0, len(music) - len(gain_samples)), constant_values=1.0)
+    else:
+        gain_samples = gain_samples[:len(music)]
+
+    return music * gain_samples
+
+
+def match_voice_levels(stems: dict[str, np.ndarray], target_rms: float = 0.1) -> dict[str, np.ndarray]:
+    """Normalize host, caller, and ads stems to the same RMS level."""
+    for name in ["host", "caller", "ads", "idents"]:
+        audio = stems[name]
+        # Only measure non-silent portions
+        active = audio[np.abs(audio) > 0.001]
+        if len(active) == 0:
+            continue
+        current_rms = np.sqrt(np.mean(active ** 2))
+        if current_rms < 1e-6:
+            continue
+        gain = target_rms / current_rms
+        # Clamp gain to avoid extreme boosts on very quiet stems
+        gain = min(gain, 10.0)
+        stems[name] = np.clip(audio * gain, -1.0, 1.0).astype(np.float32)
+        db_change = 20 * np.log10(gain) if gain > 0 else 0
+        print(f"  {name}: RMS {current_rms:.4f} -> {target_rms:.4f} ({db_change:+.1f}dB)")
+    return stems
+
+
+def mix_stems(stems: dict[str, np.ndarray],
+              levels: dict[str, float] | None = None,
+              stereo_imaging: bool = True) -> np.ndarray:
+    if levels is None:
+        levels = {"host": 0, "caller": 0, "music": -6, "sfx": -10, "ads": 0, "idents": 0}
+
+    gains = {name: 10 ** (db / 20) for name, db in levels.items()}
+
+    max_len = max(len(s) for s in stems.values())
+
+    if stereo_imaging:
+        # Pan positions: -1.0 = full left, 0.0 = center, 1.0 = full right
+        # Using constant-power panning law
+        pans = {"host": 0.0, "caller": 0.15, "music": 0.0, "sfx": 0.0, "ads": 0.0, "idents": 0.0}
+        # Music gets stereo width via slight L/R decorrelation
+        music_width = 0.3
+
+        left = np.zeros(max_len, dtype=np.float64)
+        right = np.zeros(max_len, dtype=np.float64)
+
+        for name in STEM_NAMES:
+            audio = stems[name]
+            if len(audio) < max_len:
+                audio = np.pad(audio, (0, max_len - len(audio)))
+            signal = audio.astype(np.float64) * gains.get(name, 1.0)
+
+            if name == "music" and music_width > 0:
+                # Widen music: delay right channel by ~0.5ms for Haas effect
+                delay_samples = int(0.0005 * sr)  # ~22 samples at target sample rate
+                left += signal * (1 + music_width * 0.5)
+                right_delayed = np.zeros_like(signal)
+                right_delayed[delay_samples:] = signal[:-delay_samples] if delay_samples > 0 else signal
+                right += right_delayed * (1 + music_width * 0.5)
+            else:
+                pan = pans.get(name, 0.0)
+                # Constant-power pan: L = cos(angle), R = sin(angle)
+                angle = (pan + 1) * np.pi / 4  # 0 to pi/2
+                l_gain = np.cos(angle)
+                r_gain = np.sin(angle)
+                left += signal * l_gain
+                right += signal * r_gain
+
+        left = np.clip(left, -1.0, 1.0).astype(np.float32)
+        right = np.clip(right, -1.0, 1.0).astype(np.float32)
+        stereo = np.column_stack([left, right])
+    else:
+        mix = np.zeros(max_len, dtype=np.float64)
+        for name in STEM_NAMES:
+            audio = stems[name]
+            if len(audio) < max_len:
+                audio = np.pad(audio, (0, max_len - len(audio)))
+            mix += audio.astype(np.float64) * gains.get(name, 1.0)
+        mix = np.clip(mix, -1.0, 1.0).astype(np.float32)
+        stereo = np.column_stack([mix, mix])
+
+    return stereo
+
+
+def bus_compress(audio: np.ndarray, sr: int, tmp_dir: Path) -> np.ndarray:
+    """Gentle bus compression on the final stereo mix to glue everything together."""
+    in_path = tmp_dir / "bus_pre.wav"
+    out_path = tmp_dir / "bus_post.wav"
+    sf.write(str(in_path), audio, sr)
+
+    # Gentle glue compressor: slow attack lets transients through,
+    # low ratio just levels out the overall dynamics
+    af = "acompressor=threshold=-20dB:ratio=2:attack=20:release=300:makeup=2dB"
+    cmd = ["ffmpeg", "-y", "-i", str(in_path), "-af", af, str(out_path)]
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    if result.returncode != 0:
+        print(f"  WARNING: bus compression failed: {result.stderr[:200]}")
+        return audio
+
+    compressed, _ = sf.read(str(out_path), dtype="float32")
+    return compressed
+
+
+def trim_silence(audio: np.ndarray, sr: int, pad_s: float = 0.5,
+                 threshold_db: float = -50) -> np.ndarray:
+    """Trim leading and trailing silence from stereo audio."""
+    threshold = 10 ** (threshold_db / 20)
+    # Use the louder channel for detection
+    mono = np.max(np.abs(audio), axis=1) if audio.ndim > 1 else np.abs(audio)
+
+    # Smoothed envelope for more reliable detection
+    window = int(sr * 0.05)  # 50ms window
+    if len(mono) > window:
+        kernel = np.ones(window) / window
+        envelope = np.convolve(mono, kernel, mode='same')
+    else:
+        envelope = mono
+
+    above = np.where(envelope > threshold)[0]
+    if len(above) == 0:
+        return audio
+
+    pad_samples = int(pad_s * sr)
+    start = max(0, above[0] - pad_samples)
+    end = min(len(audio), above[-1] + pad_samples)
+
+    trimmed_start = start / sr
+    trimmed_end = (len(audio) - end) / sr
+    if trimmed_start > 0.1 or trimmed_end > 0.1:
+        print(f"  Trimmed {trimmed_start:.1f}s from start, {trimmed_end:.1f}s from end")
+    else:
+        print("  No significant silence to trim")
+
+    return audio[start:end]
+
+
+def apply_fades(audio: np.ndarray, sr: int,
+                fade_in_s: float = 1.5, fade_out_s: float = 3.0) -> np.ndarray:
+    """Apply fade in/out to stereo audio using equal-power curve."""
+    audio = audio.copy()
+
+    # Fade in
+    fade_in_samples = int(fade_in_s * sr)
+    if fade_in_samples > 0 and fade_in_samples < len(audio):
+        # Equal-power: sine curve for smooth perceived volume change
+        curve = np.sin(np.linspace(0, np.pi / 2, fade_in_samples)).astype(np.float32)
+        if audio.ndim > 1:
+            audio[:fade_in_samples] *= curve[:, np.newaxis]
+        else:
+            audio[:fade_in_samples] *= curve
+
+    # Fade out
+    fade_out_samples = int(fade_out_s * sr)
+    if fade_out_samples > 0 and fade_out_samples < len(audio):
+        curve = np.sin(np.linspace(np.pi / 2, 0, fade_out_samples)).astype(np.float32)
+        if audio.ndim > 1:
+            audio[-fade_out_samples:] *= curve[:, np.newaxis]
+        else:
+            audio[-fade_out_samples:] *= curve
+
+    print(f"  Fade in: {fade_in_s}s, fade out: {fade_out_s}s")
+    return audio
+
+
+def detect_chapters(stems: dict[str, np.ndarray], sr: int) -> list[dict]:
+    """Auto-detect chapter boundaries from stem activity."""
+    window_s = 2  # 2-second analysis windows
+    window_samples = int(sr * window_s)
+    n_windows = min(len(s) for s in stems.values()) // window_samples
+
+    if n_windows == 0:
+        return []
+
+    chapters = []
+    current_type = None
+    chapter_start = 0
+
+    for w in range(n_windows):
+        start = w * window_samples
+        end = start + window_samples
+
+        ads_rms = np.sqrt(np.mean(stems["ads"][start:end] ** 2))
+        caller_rms = np.sqrt(np.mean(stems["caller"][start:end] ** 2))
+        host_rms = np.sqrt(np.mean(stems["host"][start:end] ** 2))
+
+        # Classify this window
+        if ads_rms > 0.005:
+            seg_type = "Ad Break"
+        elif caller_rms > 0.005:
+            seg_type = "Caller"
+        elif host_rms > 0.005:
+            seg_type = "Host"
+        else:
+            seg_type = current_type  # keep current during silence
+
+        if seg_type != current_type and seg_type is not None:
+            if current_type is not None:
+                chapters.append({
+                    "title": current_type,
+                    "start_ms": int(chapter_start * 1000),
+                    "end_ms": int(w * window_s * 1000),
+                })
+            current_type = seg_type
+            chapter_start = w * window_s
+
+    # Final chapter
+    if current_type is not None:
+        chapters.append({
+            "title": current_type,
+            "start_ms": int(chapter_start * 1000),
+            "end_ms": int(n_windows * window_s * 1000),
+        })
+
+    # Merge consecutive chapters of same type
+    merged = []
+    for ch in chapters:
+        if merged and merged[-1]["title"] == ch["title"]:
+            merged[-1]["end_ms"] = ch["end_ms"]
+        else:
+            merged.append(ch)
+
+    # Number duplicate types (Caller 1, Caller 2, etc.)
+    type_counts = {}
+    for ch in merged:
+        base = ch["title"]
+        type_counts[base] = type_counts.get(base, 0) + 1
+        if type_counts[base] > 1 or base in ("Caller", "Ad Break"):
+            ch["title"] = f"{base} {type_counts[base]}"
+
+    # Filter out very short chapters (< 10s)
+    merged = [ch for ch in merged if ch["end_ms"] - ch["start_ms"] >= 10000]
+
+    return merged
+
+
+def write_ffmpeg_chapters(chapters: list[dict], output_path: Path):
+    """Write an ffmpeg-format metadata file with chapter markers."""
+    lines = [";FFMETADATA1"]
+    for ch in chapters:
+        lines.append("[CHAPTER]")
+        lines.append("TIMEBASE=1/1000")
+        lines.append(f"START={ch['start_ms']}")
+        lines.append(f"END={ch['end_ms']}")
+        lines.append(f"title={ch['title']}")
+    output_path.write_text("\n".join(lines) + "\n")
+
+
+def normalize_and_export(audio: np.ndarray, sr: int, output_path: Path,
+                         target_lufs: float = -16, bitrate: str = "128k",
+                         tmp_dir: Path = None,
+                         metadata: dict | None = None,
+                         chapters_file: Path | None = None):
+    import json
+    import shutil
+
+    tmp_wav = tmp_dir / "pre_loudnorm.wav"
+    sf.write(str(tmp_wav), audio, sr)
+
+    # Pass 1: measure loudness
+    measure_cmd = [
+        "ffmpeg", "-y", "-i", str(tmp_wav),
+        "-af", f"loudnorm=I={target_lufs}:TP=-1:LRA=11:print_format=json",
+        "-f", "null", "-",
+    ]
+    result = subprocess.run(measure_cmd, capture_output=True, text=True)
+    stderr = result.stderr
+
+    json_start = stderr.rfind("{")
+    json_end = stderr.rfind("}") + 1
+    if json_start >= 0 and json_end > json_start:
+        stats = json.loads(stderr[json_start:json_end])
+    else:
+        print("  WARNING: couldn't parse loudnorm stats, using defaults")
+        stats = {
+            "input_i": "-23", "input_tp": "-1", "input_lra": "11",
+            "input_thresh": "-34",
+        }
+
+    # Pass 2: normalize + limiter + export MP3
+    loudnorm_filter = (
+        f"loudnorm=I={target_lufs}:TP=-1:LRA=11"
+        f":measured_I={stats['input_i']}"
+        f":measured_TP={stats['input_tp']}"
+        f":measured_LRA={stats['input_lra']}"
+        f":measured_thresh={stats['input_thresh']}"
+        f":linear=true"
+    )
+
+    export_cmd = ["ffmpeg", "-y", "-i", str(tmp_wav)]
+
+    if chapters_file and chapters_file.exists():
+        export_cmd += ["-i", str(chapters_file), "-map_metadata", "1"]
+
+    export_cmd += [
+        "-af", f"{loudnorm_filter},alimiter=limit=-1dB:level=false",
+        "-ab", bitrate, "-ar", str(sr),
+    ]
+
+    if metadata:
+        for key, value in metadata.items():
+            if value and not key.startswith("_"):
+                export_cmd += ["-metadata", f"{key}={value}"]
+
+    export_cmd.append(str(output_path))
+    result = subprocess.run(export_cmd, capture_output=True, text=True)
+    if result.returncode != 0:
+        print(f"  ERROR: export failed: {result.stderr[:300]}")
+        sys.exit(1)
+
+    # Embed artwork as a second pass (avoids complex multi-input mapping)
+    artwork = metadata.get("_artwork") if metadata else None
+    if artwork and Path(artwork).exists():
+        tmp_mp3 = tmp_dir / "with_art.mp3"
+        art_cmd = [
+            "ffmpeg", "-y", "-i", str(output_path), "-i", artwork,
+            "-map", "0:a", "-map", "1:0",
+            "-c:a", "copy", "-id3v2_version", "3",
+            "-metadata:s:v", "title=Album cover",
+            "-metadata:s:v", "comment=Cover (front)",
+            "-disposition:v", "attached_pic",
+            str(tmp_mp3),
+        ]
+        art_result = subprocess.run(art_cmd, capture_output=True, text=True)
+        if art_result.returncode == 0:
+            shutil.move(str(tmp_mp3), str(output_path))
+            print(f"  Embedded artwork: {artwork}")
+        else:
+            print(f"  WARNING: artwork embedding failed: {art_result.stderr[:200]}")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Post-production for AI podcast stems")
+    parser.add_argument("stems_dir", type=Path, help="Directory containing stem WAV files")
+    parser.add_argument("-o", "--output", type=str, default="episode.mp3", help="Output filename")
+    parser.add_argument("--gap-threshold", type=float, default=2.0, help="Min silence to cut (seconds)")
+    parser.add_argument("--duck-amount", type=float, default=-20, help="Music duck in dB")
+    parser.add_argument("--target-lufs", type=float, default=-16, help="Target loudness (LUFS)")
+    parser.add_argument("--bitrate", type=str, default="128k", help="MP3 bitrate")
+    parser.add_argument("--fade-in", type=float, default=1.5, help="Fade in duration (seconds)")
+    parser.add_argument("--fade-out", type=float, default=3.0, help="Fade out duration (seconds)")
+
+    # Metadata
+    parser.add_argument("--title", type=str, help="Episode title (ID3 tag)")
+    parser.add_argument("--artist", type=str, default="Luke at the Roost", help="Artist name")
+    parser.add_argument("--album", type=str, default="Luke at the Roost", help="Album/show name")
+    parser.add_argument("--episode-num", type=str, help="Episode number (track tag)")
+    parser.add_argument("--artwork", type=str, help="Path to artwork image (embedded in MP3)")
+
+    # Skip flags
+    parser.add_argument("--no-gap-removal", action="store_true", help="Skip gap removal")
+    parser.add_argument("--no-denoise", action="store_true", help="Skip noise reduction + HPF")
+    parser.add_argument("--no-deess", action="store_true", help="Skip de-essing")
+    parser.add_argument("--no-breath-reduction", action="store_true", help="Skip breath reduction")
+    parser.add_argument("--no-compression", action="store_true", help="Skip voice compression")
+    parser.add_argument("--no-phone-eq", action="store_true", help="Skip caller phone EQ")
+    parser.add_argument("--no-ducking", action="store_true", help="Skip music ducking")
+    parser.add_argument("--no-stereo", action="store_true", help="Skip stereo imaging (mono mix)")
+    parser.add_argument("--no-trim", action="store_true", help="Skip silence trimming")
+    parser.add_argument("--no-fade", action="store_true", help="Skip fade in/out")
+    parser.add_argument("--no-chapters", action="store_true", help="Skip chapter markers")
+    parser.add_argument("--dry-run", action="store_true", help="Show what would be done")
+    args = parser.parse_args()
+
+    stems_dir = args.stems_dir
+    if not stems_dir.exists():
+        print(f"ERROR: directory not found: {stems_dir}")
+        sys.exit(1)
+
+    # Resolve output path
+    output_path = Path(args.output)
+    if not output_path.is_absolute():
+        output_path = stems_dir / output_path
+
+    print(f"Post-production: {stems_dir} -> {output_path}")
+
+    if args.dry_run:
+        print("Dry run — exiting")
+        return
+
+    total_steps = 15
+
+    # Step 1: Load
+    print(f"\n[1/{total_steps}] Loading stems...")
+    stems, sr = load_stems(stems_dir)
+
+    # Step 2: Gap removal
+    print(f"\n[2/{total_steps}] Gap removal...")
+    if not args.no_gap_removal:
+        stems = remove_gaps(stems, sr, threshold_s=args.gap_threshold)
+    else:
+        print("  Skipped")
+
+    # Step 3: Limit ads + SFX (prevent clipping)
+    print(f"\n[3/{total_steps}] Limiting ads + SFX...")
+    with tempfile.TemporaryDirectory() as tmp:
+        tmp_dir = Path(tmp)
+        for name in ["ads", "sfx", "idents"]:
+            if np.any(stems[name] != 0):
+                stems[name] = limit_stem(stems[name], sr, tmp_dir, name)
+
+    # Step 4: Host mic noise reduction + HPF
+    print(f"\n[4/{total_steps}] Host noise reduction + HPF...")
+    if not args.no_denoise and np.any(stems["host"] != 0):
+        with tempfile.TemporaryDirectory() as tmp:
+            stems["host"] = denoise(stems["host"], sr, Path(tmp))
+            print("  Applied")
+    else:
+        print("  Skipped" if args.no_denoise else "  No host audio")
+
+    # Step 5: De-essing
+    print(f"\n[5/{total_steps}] De-essing host...")
+    if not args.no_deess and np.any(stems["host"] != 0):
+        with tempfile.TemporaryDirectory() as tmp:
+            stems["host"] = deess(stems["host"], sr, Path(tmp))
+            print("  Applied")
+    else:
+        print("  Skipped" if args.no_deess else "  No host audio")
+
+    # Step 6: Breath reduction
+    print(f"\n[6/{total_steps}] Breath reduction...")
+    if not args.no_breath_reduction and np.any(stems["host"] != 0):
+        stems["host"] = reduce_breaths(stems["host"], sr)
+    else:
+        print("  Skipped" if args.no_breath_reduction else "  No host audio")
+
+    # Step 7: Voice compression
+    print(f"\n[7/{total_steps}] Voice compression...")
+    if not args.no_compression:
+        with tempfile.TemporaryDirectory() as tmp:
+            tmp_dir = Path(tmp)
+            for name in ["host", "caller"]:
+                if np.any(stems[name] != 0):
+                    print(f"  Compressing {name}...")
+                    stems[name] = compress_voice(stems[name], sr, tmp_dir, name)
+    else:
+        print("  Skipped")
+
+    # Step 8: Phone EQ on caller
+    print(f"\n[8/{total_steps}] Phone EQ on caller...")
+    if not args.no_phone_eq and np.any(stems["caller"] != 0):
+        with tempfile.TemporaryDirectory() as tmp:
+            stems["caller"] = phone_eq(stems["caller"], sr, Path(tmp))
+            print("  Applied")
+    else:
+        print("  Skipped" if args.no_phone_eq else "  No caller audio")
+
+    # Step 9: Match voice levels
+    print(f"\n[9/{total_steps}] Matching voice levels...")
+    stems = match_voice_levels(stems)
+
+    # Step 10: Music ducking
+    print(f"\n[10/{total_steps}] Music ducking...")
+    if not args.no_ducking:
+        dialog = stems["host"] + stems["caller"]
+        if np.any(dialog != 0) and np.any(stems["music"] != 0):
+            stems["music"] = apply_ducking(stems["music"], dialog, sr, duck_db=args.duck_amount,
+                                           mute_signal=stems["ads"] + stems["idents"])
+            print("  Applied")
+        else:
+            print("  No dialog or music to duck")
+    else:
+        print("  Skipped")
+
+    # Step 11: Stereo mix
+    print(f"\n[11/{total_steps}] Mixing...")
+    stereo = mix_stems(stems, stereo_imaging=not args.no_stereo)
+    imaging = "stereo" if not args.no_stereo else "mono"
+    print(f"  Mixed to {imaging}: {len(stereo)} samples ({len(stereo)/sr:.1f}s)")
+
+    # Step 12: Bus compression
+    print(f"\n[12/{total_steps}] Bus compression...")
+    with tempfile.TemporaryDirectory() as tmp:
+        stereo = bus_compress(stereo, sr, Path(tmp))
+        print("  Applied")
+
+    # Step 13: Silence trimming
+    print(f"\n[13/{total_steps}] Trimming silence...")
+    if not args.no_trim:
+        stereo = trim_silence(stereo, sr)
+    else:
+        print("  Skipped")
+
+    # Step 14: Fade in/out
+    print(f"\n[14/{total_steps}] Fades...")
+    if not args.no_fade:
+        stereo = apply_fades(stereo, sr, fade_in_s=args.fade_in, fade_out_s=args.fade_out)
+    else:
+        print("  Skipped")
+
+    # Step 15: Normalize + export with metadata and chapters
+    print(f"\n[15/{total_steps}] Loudness normalization + export...")
+
+    # Build metadata dict
+    meta = {}
+    if args.title:
+        meta["title"] = args.title
+    if args.artist:
+        meta["artist"] = args.artist
+    if args.album:
+        meta["album"] = args.album
+    if args.episode_num:
+        meta["track"] = args.episode_num
+    if args.artwork:
+        meta["_artwork"] = args.artwork
+
+    # Auto-detect chapters
+    chapters = []
+    if not args.no_chapters:
+        chapters = detect_chapters(stems, sr)
+        if chapters:
+            print(f"  Detected {len(chapters)} chapters:")
+            for ch in chapters:
+                start_s = ch["start_ms"] / 1000
+                end_s = ch["end_ms"] / 1000
+                print(f"    {start_s:6.1f}s - {end_s:6.1f}s  {ch['title']}")
+        else:
+            print("  No chapters detected")
+    else:
+        print("  Skipped")
+
+    with tempfile.TemporaryDirectory() as tmp:
+        tmp_dir = Path(tmp)
+
+        chapters_file = None
+        if chapters:
+            chapters_file = tmp_dir / "chapters.txt"
+            write_ffmpeg_chapters(chapters, chapters_file)
+
+        normalize_and_export(stereo, sr, output_path,
+                             target_lufs=args.target_lufs,
+                             bitrate=args.bitrate,
+                             tmp_dir=tmp_dir,
+                             metadata=meta if meta else None,
+                             chapters_file=chapters_file)
+
+    print(f"\nDone! Output: {output_path}")
+
+
+if __name__ == "__main__":
+    main()

reaper/dialog_regions.lua

@@ -0,0 +1,115 @@
+-- Show Region Marker — background script for REAPER
+-- Polls /tmp/reaper_state.txt for state changes and creates colored regions.
+-- Backend writes "dialog", "ad", or "ident" to the file.
+-- Run via Actions → Run ReaScript before or during recording.
+
+local STATE_FILE = "/tmp/reaper_state.txt"
+
+local COLORS = {
+  dialog = reaper.ColorToNative(50, 180, 50) + 0x1000000,   -- green
+  ad     = reaper.ColorToNative(200, 80, 80) + 0x1000000,   -- red
+  ident  = reaper.ColorToNative(80, 120, 200) + 0x1000000,  -- blue
+}
+local LABELS = {
+  dialog = "DIALOG",
+  ad     = "AD",
+  ident  = "IDENT",
+}
+
+local counts = { dialog = 0, ad = 0, ident = 0 }
+local current_type = nil    -- which region type is currently open
+local current_start = 0
+local last_pos = 0          -- last known transport position (while running)
+local last_state = ""
+local transport_active = false
+
+local function log(msg)
+  reaper.ShowConsoleMsg("[Regions] " .. msg .. "\n")
+end
+
+local function is_playing_or_recording()
+  local state = reaper.GetPlayState()
+  return state > 0 and state ~= 2
+end
+
+local function open_region(rtype)
+  if current_type then return end
+  current_type = rtype
+  current_start = reaper.GetPlayPosition()
+  log("OPEN " .. rtype .. " at " .. string.format("%.2f", current_start))
+end
+
+local function close_region(pos_override)
+  if not current_type then return end
+  local pos = pos_override or reaper.GetPlayPosition()
+  local len = pos - current_start
+  local rtype = current_type
+  current_type = nil
+  log("CLOSE " .. rtype .. " at " .. string.format("%.2f", pos) .. " (len=" .. string.format("%.2f", len) .. ")")
+  if len > 0.1 then
+    counts[rtype] = counts[rtype] + 1
+    local name = LABELS[rtype] .. " " .. counts[rtype]
+    reaper.AddProjectMarker2(0, true, current_start, pos, name, -1, COLORS[rtype])
+    log("  -> Created '" .. name .. "'")
+  else
+    log("  -> Skipped (too short)")
+  end
+end
+
+local function poll()
+  if not transport_active then
+    if is_playing_or_recording() then
+      transport_active = true
+      log("Transport started at " .. string.format("%.2f", reaper.GetPlayPosition()))
+      local f = io.open(STATE_FILE, "r")
+      if f then
+        last_state = f:read("*l") or "dialog"
+        f:close()
+      else
+        last_state = "dialog"
+      end
+      log("Initial state: '" .. last_state .. "'")
+      open_region(last_state)
+    end
+    reaper.defer(poll)
+    return
+  end
+
+  -- Track position while transport is running
+  last_pos = reaper.GetPlayPosition()
+
+  -- Detect transport stop (recording ended) — use last known good position
+  if not is_playing_or_recording() then
+    log("Transport stopped at last known pos " .. string.format("%.2f", last_pos))
+    close_region(last_pos)
+    transport_active = false
+    reaper.defer(poll)
+    return
+  end
+
+  local f = io.open(STATE_FILE, "r")
+  if f then
+    local state = f:read("*l") or "dialog"
+    f:close()
+
+    if state ~= last_state then
+      log("State change: '" .. last_state .. "' -> '" .. state .. "'")
+      close_region()
+      open_region(state)
+      last_state = state
+    end
+  end
+
+  reaper.defer(poll)
+end
+
+log("Script loaded — waiting for transport to start...")
+
+reaper.atexit(function()
+  log("Script stopping (atexit)")
+  close_region()
+  local total = counts.dialog + counts.ad + counts.ident
+  log("Done. " .. total .. " regions (" .. counts.dialog .. " dialog, " .. counts.ad .. " ad, " .. counts.ident .. " ident)")
+end)
+
+poll()

relabel_transcripts.py

@@ -0,0 +1,194 @@
+#!/usr/bin/env python3
+"""Re-label podcast transcripts with LUKE:/CALLER: speaker labels using LLM."""
+
+import os, re, sys, time, requests
+from pathlib import Path
+from dotenv import load_dotenv
+
+load_dotenv()
+API_KEY = os.getenv("OPENROUTER_API_KEY")
+TRANSCRIPT_DIR = Path(__file__).parent / "website" / "transcripts"
+MODEL = "anthropic/claude-3.5-sonnet"
+CHUNK_SIZE = 8000
+
+PROMPT = """Insert speaker labels into this radio show transcript. The show is "Luke at the Roost". The host is LUKE. Callers call in one at a time.
+
+CRITICAL: Output EVERY SINGLE WORD from the input. Do NOT summarize, shorten, paraphrase, or skip ANY text. The output must contain the EXACT SAME words as the input, with ONLY speaker labels and line breaks added.
+
+At each speaker change, insert a blank line and the new speaker's label (e.g., "LUKE:" or "REGGIE:").
+
+Speaker identification:
+- LUKE is the host — he introduces callers, asks questions, does sponsor reads, opens and closes the show
+- Callers are introduced by name by Luke (e.g., "let's talk to Earl", "next up Brenda")
+- Use caller FIRST NAME in caps as the label
+- When Luke says "Tell me about..." or asks a question, that's LUKE
+- When someone responds with their story/opinion/answer, that's the CALLER
+
+Output format — ONLY the labeled transcript with blank lines between turns. No notes, no commentary."""
+
+CONTEXT_PROMPT = "\n\nCONTEXT: The previous section ended with the speaker {speaker}. Last few words: \"{tail}\""
+
+
+def chunk_text(text, max_chars=CHUNK_SIZE):
+    if len(text) <= max_chars:
+        return [text]
+
+    chunks = []
+    while text:
+        if len(text) <= max_chars:
+            # Merge tiny tails into the previous chunk
+            if chunks and len(text) < 1000:
+                chunks[-1] = chunks[-1] + " " + text
+            else:
+                chunks.append(text)
+            break
+
+        # Find a good break point near max_chars
+        pos = text[:max_chars].rfind('. ')
+        if pos < max_chars // 2:
+            pos = text[:max_chars].rfind('? ')
+        if pos < max_chars // 2:
+            pos = text[:max_chars].rfind('! ')
+        if pos < max_chars // 2:
+            pos = max_chars
+
+        chunks.append(text[:pos + 1].strip())
+        text = text[pos + 1:].strip()
+
+    return chunks
+
+
+def label_chunk(text, context=""):
+    prompt = PROMPT + "\n\nTRANSCRIPT:\n" + text
+    if context:
+        prompt += context
+
+    response = requests.post(
+        "https://openrouter.ai/api/v1/chat/completions",
+        headers={
+            "Authorization": f"Bearer {API_KEY}",
+            "Content-Type": "application/json"
+        },
+        json={
+            "model": MODEL,
+            "messages": [{"role": "user", "content": prompt}],
+            "max_tokens": 8192,
+            "temperature": 0
+        }
+    )
+
+    if response.status_code != 200:
+        print(f"  API error: {response.status_code} {response.text[:200]}")
+        return None
+
+    content = response.json()["choices"][0]["message"]["content"].strip()
+
+    # Remove any markdown code block wrappers
+    if content.startswith("```"):
+        content = re.sub(r'^```\w*\n?', '', content)
+        content = re.sub(r'\n?```$', '', content)
+
+    return content
+
+
+def get_last_speaker(text):
+    lines = text.strip().split('\n')
+    for line in reversed(lines):
+        match = re.match(r'^([A-Z][A-Z\s\'-]+?):', line.strip())
+        if match:
+            return match.group(1)
+    return "LUKE"
+
+
+def validate_output(original, labeled):
+    """Basic validation that the output looks right."""
+    # Check that speaker labels exist (at least 1 for short chunks)
+    speaker_lines = re.findall(r'^[A-Z][A-Z\s\'-]+?:', labeled, re.MULTILINE)
+    if len(speaker_lines) < 1:
+        return False
+
+    # Check that output isn't drastically shorter (allowing for some reformatting)
+    orig_words = len(original.split())
+    labeled_words = len(labeled.split())
+    if labeled_words < orig_words * 0.5:
+        print(f"  WARNING: Output is {labeled_words} words vs {orig_words} input words ({labeled_words * 100 // orig_words}%)")
+        return False
+
+    return True
+
+
+def process_transcript(filepath):
+    text = filepath.read_text().strip()
+    # Strip existing timestamp markers
+    text = re.sub(r'\[[\d:]+\]\s*', '', text)
+    # Normalize whitespace
+    text = re.sub(r'\n+', ' ', text)
+    text = re.sub(r'\s+', ' ', text).strip()
+
+    print(f"  {len(text)} chars")
+
+    chunks = chunk_text(text)
+    print(f"  {len(chunks)} chunk(s)")
+
+    labeled_parts = []
+    context = ""
+
+    for i, chunk in enumerate(chunks):
+        print(f"  Processing chunk {i + 1}/{len(chunks)} ({len(chunk)} chars)...")
+        labeled = label_chunk(chunk, context)
+
+        if labeled is None:
+            print(f"  ERROR: API call failed for chunk {i + 1}")
+            return None
+
+        if not validate_output(chunk, labeled):
+            print(f"  ERROR: Validation failed for chunk {i + 1}")
+            return None
+
+        labeled_parts.append(labeled)
+
+        # Build context for next chunk
+        last_speaker = get_last_speaker(labeled)
+        tail = labeled.strip()[-100:]
+        context = CONTEXT_PROMPT.format(speaker=last_speaker, tail=tail)
+
+        if i < len(chunks) - 1:
+            time.sleep(0.5)
+
+    # Join parts, ensuring proper spacing between chunks
+    result = "\n\n".join(labeled_parts)
+    # Normalize: ensure exactly one blank line between speaker turns
+    result = re.sub(r'\n{3,}', '\n\n', result)
+    # Fix format: put speaker label on same line as text (SPEAKER:\ntext -> SPEAKER: text)
+    result = re.sub(r'^([A-Z][A-Z\s\'-]+?):\s*\n(?!\n)', r'\1: ', result, flags=re.MULTILINE)
+    return result
+
+
+def main():
+    if not API_KEY:
+        print("Error: OPENROUTER_API_KEY not set")
+        sys.exit(1)
+
+    files = sys.argv[1:] if len(sys.argv) > 1 else None
+    if files:
+        transcripts = [TRANSCRIPT_DIR / f for f in files]
+    else:
+        transcripts = sorted(TRANSCRIPT_DIR.glob("*.txt"))
+
+    for filepath in transcripts:
+        if not filepath.exists():
+            print(f"Skipping {filepath.name} (not found)")
+            continue
+        print(f"\nProcessing: {filepath.name}")
+        labeled = process_transcript(filepath)
+        if labeled is None:
+            print(f"  SKIPPED (processing failed)")
+            continue
+        filepath.write_text(labeled + "\n")
+        print(f"  Saved ({len(labeled)} chars)")
+
+    print("\nDone!")
+
+
+if __name__ == "__main__":
+    main()

run.sh

@@ -1,6 +1,7 @@
 #!/bin/bash
 # AI Radio Show - Server Runner with restart support
 
+PORT=8000
 LOG_FILE="/tmp/ai-radio-show.log"
 RESTART_FLAG="/tmp/ai-radio-show.restart"
 STOP_FLAG="/tmp/ai-radio-show.stop"
@@ -13,16 +14,46 @@ source venv/bin/activate
 # Cleanup old flags
 rm -f "$RESTART_FLAG" "$STOP_FLAG"
 
+# Check if port is already in use
+if lsof -i ":$PORT" -sTCP:LISTEN -t >/dev/null 2>&1; then
+    EXISTING_PID=$(lsof -i ":$PORT" -sTCP:LISTEN -t 2>/dev/null | head -1)
+    echo "ERROR: Port $PORT is already in use by PID $EXISTING_PID"
+    echo "Run: kill $EXISTING_PID"
+    exit 1
+fi
+
+kill_server() {
+    local pid=$1
+    if ! kill -0 "$pid" 2>/dev/null; then
+        return
+    fi
+    kill "$pid" 2>/dev/null
+    # Wait up to 5 seconds for graceful shutdown
+    for i in $(seq 1 10); do
+        if ! kill -0 "$pid" 2>/dev/null; then
+            return
+        fi
+        sleep 0.5
+    done
+    # Force kill if still alive
+    echo "[$(date)] Server didn't stop gracefully, force killing..." | tee -a "$LOG_FILE"
+    kill -9 "$pid" 2>/dev/null
+    wait "$pid" 2>/dev/null
+}
+
 echo "AI Radio Show Server Runner"
 echo "Log file: $LOG_FILE"
 echo "Press Ctrl+C to stop"
 echo ""
 
-while true; do
-    echo "[$(date)] Starting server..." | tee -a "$LOG_FILE"
+# Handle Ctrl+C
+trap 'echo ""; echo "[$(date)] Interrupted" | tee -a "$LOG_FILE"; kill_server $SERVER_PID; exit 0' INT TERM
 
-    # Start uvicorn with output to both console and log file
-    python -m uvicorn backend.main:app --host 0.0.0.0 --port 8000 2>&1 | tee -a "$LOG_FILE" &
+while true; do
+    echo "[$(date)] Starting server on port $PORT..." | tee -a "$LOG_FILE"
+
+    # Start uvicorn directly (not through tee pipe so we get the real PID)
+    python -m uvicorn backend.main:app --host 0.0.0.0 --port $PORT >> "$LOG_FILE" 2>&1 &
     SERVER_PID=$!
 
     # Wait for server to exit or restart signal
@@ -30,8 +61,7 @@ while true; do
         if [ -f "$RESTART_FLAG" ]; then
             echo "[$(date)] Restart requested..." | tee -a "$LOG_FILE"
             rm -f "$RESTART_FLAG"
-            kill $SERVER_PID 2>/dev/null
-            wait $SERVER_PID 2>/dev/null
+            kill_server $SERVER_PID
             sleep 1
             break
         fi
@@ -39,8 +69,7 @@ while true; do
         if [ -f "$STOP_FLAG" ]; then
             echo "[$(date)] Stop requested..." | tee -a "$LOG_FILE"
             rm -f "$STOP_FLAG"
-            kill $SERVER_PID 2>/dev/null
-            wait $SERVER_PID 2>/dev/null
+            kill_server $SERVER_PID
             echo "[$(date)] Server stopped." | tee -a "$LOG_FILE"
             exit 0
         fi

scan_music_vocals.py

@@ -0,0 +1,122 @@
+"""Scan music directory for tracks that contain vocals/lyrics.
+
+Uses Whisper to transcribe a sample from each track — if it picks up
+actual words, the track likely has vocals.
+
+Usage:
+    python scan_music_vocals.py              # scan and report
+    python scan_music_vocals.py --delete     # scan and delete vocal tracks
+"""
+
+import argparse
+import sys
+from pathlib import Path
+
+import librosa
+import numpy as np
+from faster_whisper import WhisperModel
+
+MUSIC_DIR = Path(__file__).parent / "music"
+WHISPER_MODEL = "distil-large-v3"
+
+# Words Whisper hallucinates on silence/instrumental — ignore these
+HALLUCINATION_PHRASES = {
+    "thank you", "thanks for watching", "subscribe", "like and subscribe",
+    "please subscribe", "thank you for watching", "thanks for listening",
+    "you", "the end", "bye", "okay",
+}
+
+
+def scan_track(model: WhisperModel, filepath: Path) -> tuple[bool, str]:
+    """Check a single track for vocals. Returns (has_vocals, transcription)."""
+    try:
+        audio, sr = librosa.load(str(filepath), sr=16000, mono=True)
+    except Exception as e:
+        return False, f"[load error: {e}]"
+
+    duration = len(audio) / sr
+    if duration < 10:
+        return False, "[too short]"
+
+    # Sample 30s from the middle (most likely to have vocals)
+    mid = len(audio) // 2
+    half_window = int(15 * sr)  # 15s each side
+    start = max(0, mid - half_window)
+    end = min(len(audio), mid + half_window)
+    sample = audio[start:end]
+
+    segments, info = model.transcribe(
+        sample,
+        beam_size=3,
+        language="en",
+        vad_filter=True,
+        vad_parameters=dict(min_speech_duration_ms=500),
+    )
+    segments_list = list(segments)
+    text = " ".join(s.text for s in segments_list).strip()
+
+    # Filter out Whisper hallucinations
+    text_lower = text.lower().strip()
+    if text_lower in HALLUCINATION_PHRASES or len(text_lower) < 4:
+        return False, ""
+
+    # If Whisper found substantial text, it's likely vocals
+    word_count = len(text.split())
+    has_vocals = word_count >= 3
+
+    return has_vocals, text
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Scan music for vocal tracks")
+    parser.add_argument("--delete", action="store_true", help="Delete tracks with vocals")
+    args = parser.parse_args()
+
+    audio_files = sorted(
+        f for f in MUSIC_DIR.iterdir()
+        if f.suffix.lower() in {".mp3", ".wav", ".ogg", ".flac"}
+    )
+
+    if not audio_files:
+        print("No audio files found in music/")
+        return
+
+    print(f"Loading Whisper {WHISPER_MODEL}...")
+    model = WhisperModel(WHISPER_MODEL, device="cpu", compute_type="int8")
+
+    print(f"Scanning {len(audio_files)} tracks for vocals...\n")
+
+    vocal_tracks = []
+    for i, f in enumerate(audio_files, 1):
+        print(f"[{i}/{len(audio_files)}] {f.name}...", end=" ", flush=True)
+        has_vocals, text = scan_track(model, f)
+        if has_vocals:
+            print(f"VOCALS: {text[:80]}")
+            vocal_tracks.append((f, text))
+        else:
+            print("OK")
+
+    print(f"\n{'='*60}")
+    print(f"Results: {len(vocal_tracks)} tracks with vocals out of {len(audio_files)}\n")
+
+    if not vocal_tracks:
+        print("All tracks appear to be instrumental!")
+        return
+
+    for f, text in vocal_tracks:
+        print(f"  {f.name}")
+        print(f"    Lyrics: {text[:120]}")
+        print()
+
+    if args.delete:
+        print(f"Deleting {len(vocal_tracks)} vocal tracks...")
+        for f, _ in vocal_tracks:
+            f.unlink()
+            print(f"  Deleted: {f.name}")
+        print("Done.")
+    else:
+        print("Run with --delete to remove these tracks.")
+
+
+if __name__ == "__main__":
+    main()

tests/test_caller_service.py

@@ -0,0 +1,135 @@
+import sys
+sys.path.insert(0, "/Users/lukemacneil/ai-podcast")
+
+from backend.services.caller_service import CallerService
+
+
+def test_queue_starts_empty():
+    svc = CallerService()
+    assert svc.get_queue() == []
+
+
+def test_add_caller_to_queue():
+    svc = CallerService()
+    svc.add_to_queue("abc123", "+15551234567")
+    q = svc.get_queue()
+    assert len(q) == 1
+    assert q[0]["caller_id"] == "abc123"
+    assert q[0]["phone"] == "+15551234567"
+    assert "wait_time" in q[0]
+
+
+def test_remove_caller_from_queue():
+    svc = CallerService()
+    svc.add_to_queue("abc123", "+15551234567")
+    svc.remove_from_queue("abc123")
+    assert svc.get_queue() == []
+
+
+def test_allocate_channel():
+    svc = CallerService()
+    ch1 = svc.allocate_channel()
+    ch2 = svc.allocate_channel()
+    assert ch1 == 3
+    assert ch2 == 4
+    svc.release_channel(ch1)
+    ch3 = svc.allocate_channel()
+    assert ch3 == 3
+
+
+def test_take_call():
+    svc = CallerService()
+    svc.add_to_queue("abc123", "+15551234567")
+    result = svc.take_call("abc123")
+    assert result["caller_id"] == "abc123"
+    assert result["channel"] >= 3
+    assert svc.get_queue() == []
+    assert svc.active_calls["abc123"]["channel"] == result["channel"]
+
+
+def test_hangup_real_caller():
+    svc = CallerService()
+    svc.add_to_queue("abc123", "+15551234567")
+    svc.take_call("abc123")
+    ch = svc.active_calls["abc123"]["channel"]
+    svc.hangup("abc123")
+    assert "abc123" not in svc.active_calls
+    assert ch not in svc._allocated_channels
+
+
+def test_caller_counter_increments():
+    svc = CallerService()
+    svc.add_to_queue("id1", "+15551234567")
+    svc.add_to_queue("id2", "+15559876543")
+    r1 = svc.take_call("id1")
+    r2 = svc.take_call("id2")
+    assert r1["phone"] == "+15551234567"
+    assert r2["phone"] == "+15559876543"
+
+
+def test_register_and_unregister_websocket():
+    svc = CallerService()
+    fake_ws = object()
+    svc.register_websocket("abc123", fake_ws)
+    assert svc._websockets["abc123"] is fake_ws
+    svc.unregister_websocket("abc123")
+    assert "abc123" not in svc._websockets
+
+
+def test_hangup_clears_websocket():
+    svc = CallerService()
+    svc.add_to_queue("abc123", "+15551234567")
+    svc.take_call("abc123")
+    svc.register_websocket("abc123", object())
+    svc.hangup("abc123")
+    assert "abc123" not in svc._websockets
+
+
+def test_reset_clears_websockets():
+    svc = CallerService()
+    svc.register_websocket("id1", object())
+    svc.register_websocket("id2", object())
+    svc.reset()
+    assert svc._websockets == {}
+
+
+def test_send_audio_no_websocket():
+    """send_audio_to_caller returns silently when no WS registered"""
+    import asyncio
+    svc = CallerService()
+    asyncio.get_event_loop().run_until_complete(
+        svc.send_audio_to_caller("NONE", b"\x00" * 100, 16000)
+    )
+
+
+def test_send_audio_json():
+    """send_audio_to_caller sends base64 JSON via SignalWire protocol"""
+    import asyncio
+    import json
+    import base64
+
+    class FakeWS:
+        def __init__(self):
+            self.sent_text = []
+        async def send_text(self, data):
+            self.sent_text.append(data)
+
+    svc = CallerService()
+    ws = FakeWS()
+    svc.register_websocket("abc123", ws)
+    pcm = b"\x00\x01" * 100
+    asyncio.get_event_loop().run_until_complete(
+        svc.send_audio_to_caller("abc123", pcm, 16000)
+    )
+    assert len(ws.sent_text) == 1
+    msg = json.loads(ws.sent_text[0])
+    assert msg["event"] == "media"
+    assert base64.b64decode(msg["media"]["payload"]) == pcm
+
+
+def test_take_call_preserves_caller_phone():
+    """take_call uses the phone from the queue"""
+    svc = CallerService()
+    svc.add_to_queue("abc123", "+15551234567")
+    result = svc.take_call("abc123")
+    assert result["phone"] == "+15551234567"

tests/test_followup.py

@@ -0,0 +1,39 @@
+import sys
+sys.path.insert(0, "/Users/lukemacneil/ai-podcast")
+
+from backend.main import Session, CallRecord, get_caller_prompt
+
+
+def test_caller_prompt_includes_show_history():
+    s = Session()
+    s.call_history.append(CallRecord(
+        caller_type="real", caller_name="Dave",
+        summary="Called about his wife leaving after 12 years",
+        transcript=[],
+    ))
+
+    s.start_call("1")  # Tony
+    caller = s.caller
+    show_history = s.get_show_history()
+    prompt = get_caller_prompt(caller, "", show_history)
+    assert "Dave" in prompt
+    assert "wife leaving" in prompt
+    assert "EARLIER IN THE SHOW" in prompt
+
+
+def test_caller_prompt_without_history():
+    s = Session()
+    s.start_call("1")
+    caller = s.caller
+    prompt = get_caller_prompt(caller, "")
+    assert "EARLIER IN THE SHOW" not in prompt
+    assert caller["name"] in prompt
+
+
+def test_caller_prompt_backward_compatible():
+    """Verify get_caller_prompt works with just 2 args (no show_history)"""
+    s = Session()
+    s.start_call("1")
+    caller = s.caller
+    prompt = get_caller_prompt(caller, "Host: hello")
+    assert "hello" in prompt

tests/test_session.py

@@ -0,0 +1,89 @@
+import sys
+sys.path.insert(0, "/Users/lukemacneil/ai-podcast")
+
+from backend.main import Session, CallRecord
+
+
+def test_call_record_creation():
+    record = CallRecord(
+        caller_type="real",
+        caller_name="Dave",
+        summary="Called about his wife leaving",
+        transcript=[{"role": "host", "content": "What happened?"}],
+    )
+    assert record.caller_type == "real"
+    assert record.caller_name == "Dave"
+
+
+def test_session_call_history():
+    s = Session()
+    assert s.call_history == []
+    record = CallRecord(
+        caller_type="ai", caller_name="Tony",
+        summary="Talked about gambling", transcript=[],
+    )
+    s.call_history.append(record)
+    assert len(s.call_history) == 1
+
+
+def test_session_active_real_caller():
+    s = Session()
+    assert s.active_real_caller is None
+    s.active_real_caller = {
+        "caller_id": "abc123",
+        "channel": 3, "name": "Dave",
+    }
+    assert s.active_real_caller["channel"] == 3
+
+
+def test_session_three_party_conversation():
+    s = Session()
+    s.start_call("1")  # AI caller Tony
+    s.add_message("host", "Hey Tony")
+    s.add_message("ai_caller:Tony", "What's up man")
+    s.add_message("real_caller:Dave", "Yeah I agree with Tony")
+    assert len(s.conversation) == 3
+    assert s.conversation[2]["role"] == "real_caller:Dave"
+
+
+def test_session_get_show_history_summary():
+    s = Session()
+    s.call_history.append(CallRecord(
+        caller_type="real", caller_name="Dave",
+        summary="Called about his wife leaving after 12 years",
+        transcript=[],
+    ))
+    s.call_history.append(CallRecord(
+        caller_type="ai", caller_name="Jasmine",
+        summary="Talked about her boss hitting on her",
+        transcript=[],
+    ))
+    summary = s.get_show_history()
+    assert "Dave" in summary
+    assert "Jasmine" in summary
+    assert "EARLIER IN THE SHOW" in summary
+
+
+def test_session_reset_clears_history():
+    s = Session()
+    s.call_history.append(CallRecord(
+        caller_type="real", caller_name="Dave",
+        summary="test", transcript=[],
+    ))
+    s.active_real_caller = {"caller_id": "abc123"}
+    s.ai_respond_mode = "auto"
+    s.reset()
+    assert s.call_history == []
+    assert s.active_real_caller is None
+    assert s.ai_respond_mode == "manual"
+
+
+def test_session_conversation_summary_three_party():
+    s = Session()
+    s.start_call("1")
+    s.add_message("host", "Tell me what happened")
+    s.add_message("real_caller:Dave", "She just left man")
+    s.add_message("ai_caller:Tony", "Same thing happened to me")
+    summary = s.get_conversation_summary()
+    assert "Dave" in summary
+    assert "Tony" in summary

upload_clips.py

@@ -0,0 +1,787 @@
+#!/usr/bin/env python3
+"""Upload podcast clips to social media (direct YouTube & Bluesky, Postiz for others).
+
+Usage:
+    python upload_clips.py                          # interactive: pick episode, clips, platforms
+    python upload_clips.py clips/episode-12/        # pick clips and platforms interactively
+    python upload_clips.py clips/episode-12/ --clip 1 --platforms ig,yt
+    python upload_clips.py clips/episode-12/ --yes  # skip all prompts, upload everything
+"""
+
+import argparse
+import json
+import re
+import sys
+from pathlib import Path
+
+import requests
+from atproto import Client as BskyClient
+from dotenv import load_dotenv
+import os
+
+load_dotenv(Path(__file__).parent / ".env")
+
+POSTIZ_API_KEY = os.getenv("POSTIZ_API_KEY")
+POSTIZ_URL = os.getenv("POSTIZ_URL", "https://social.lukeattheroost.com")
+POSTIZ_INTEGRATIONS = json.loads(os.getenv("POSTIZ_INTEGRATIONS", "{}"))
+
+BSKY_HANDLE = os.getenv("BSKY_HANDLE", "lukeattheroost.bsky.social")
+BSKY_APP_PASSWORD = os.getenv("BSKY_APP_PASSWORD")
+
+YT_CLIENT_SECRETS = Path(__file__).parent / "youtube_client_secrets.json"
+YT_TOKEN_FILE = Path(__file__).parent / "youtube_token.json"
+
+PLATFORM_ALIASES = {
+    "ig": "instagram", "insta": "instagram", "instagram": "instagram",
+    "yt": "youtube", "youtube": "youtube",
+    "fb": "facebook", "facebook": "facebook",
+    "bsky": "bluesky", "bluesky": "bluesky",
+    "masto": "mastodon", "mastodon": "mastodon",
+    "nostr": "nostr",
+    "li": "linkedin", "linkedin": "linkedin",
+    "threads": "threads",
+    "tt": "tiktok", "tiktok": "tiktok",
+}
+
+PLATFORM_DISPLAY = {
+    "instagram": "Instagram Reels",
+    "youtube": "YouTube Shorts",
+    "facebook": "Facebook Reels",
+    "bluesky": "Bluesky",
+    "mastodon": "Mastodon",
+    "nostr": "Nostr",
+    "linkedin": "LinkedIn",
+    "threads": "Threads",
+    "tiktok": "TikTok",
+}
+
+ALL_PLATFORMS = list(PLATFORM_DISPLAY.keys())
+
+UPLOAD_LEDGER_FILE = "upload-history.json"
+
+
+def load_upload_history(clips_dir: Path) -> dict:
+    """Load upload history for a clips directory.
+    Returns dict mapping clip_file -> list of platforms already uploaded to.
+    """
+    ledger = clips_dir / UPLOAD_LEDGER_FILE
+    if ledger.exists():
+        with open(ledger) as f:
+            return json.load(f)
+    return {}
+
+
+def save_upload_history(clips_dir: Path, history: dict):
+    with open(clips_dir / UPLOAD_LEDGER_FILE, "w") as f:
+        json.dump(history, f, indent=2)
+
+
+def get_api_url(path: str) -> str:
+    base = POSTIZ_URL.rstrip("/")
+    return f"{base}/api/public/v1{path}"
+
+
+def api_headers() -> dict:
+    return {
+        "Authorization": POSTIZ_API_KEY,
+        "Content-Type": "application/json",
+    }
+
+
+def fetch_integrations() -> list[dict]:
+    resp = requests.get(get_api_url("/integrations"), headers=api_headers(), timeout=15)
+    if resp.status_code != 200:
+        print(f"Error fetching integrations: {resp.status_code} {resp.text[:200]}")
+        sys.exit(1)
+    return resp.json()
+
+
+BLOCKED_INTEGRATION_IDS = {
+    "cmluam50j0001o46xifujx059",  # Personal LinkedIn (CareerPulse) — never post podcast content here
+}
+
+def find_integration(integrations: list[dict], provider: str) -> dict | None:
+    # Prefer hardcoded integration ID from .env (avoids picking wrong account)
+    if provider in POSTIZ_INTEGRATIONS:
+        target_id = POSTIZ_INTEGRATIONS[provider].get("id")
+        if target_id:
+            for integ in integrations:
+                if integ.get("id") == target_id:
+                    return integ
+    # Fallback: first matching provider (skip blocked accounts)
+    for integ in integrations:
+        if integ.get("id") in BLOCKED_INTEGRATION_IDS:
+            continue
+        if integ.get("identifier", "").startswith(provider) and not integ.get("disabled"):
+            return integ
+    return None
+
+
+def upload_file(file_path: Path) -> dict:
+    headers = {"Authorization": POSTIZ_API_KEY}
+    with open(file_path, "rb") as f:
+        resp = requests.post(
+            get_api_url("/upload"),
+            headers=headers,
+            files={"file": (file_path.name, f, "video/mp4")},
+            timeout=120,
+        )
+    if resp.status_code not in (200, 201):
+        print(f"Upload failed: {resp.status_code} {resp.text[:200]}")
+        return {}
+    return resp.json()
+
+
+def build_content(clip: dict, platform: str) -> str:
+    desc = clip.get("description", clip.get("caption_text", ""))
+    hashtags = clip.get("hashtags", [])
+    hashtag_str = " ".join(hashtags)
+
+    if platform == "bluesky":
+        if hashtags and len(desc) + 2 + len(hashtag_str) <= 300:
+            return desc + "\n\n" + hashtag_str
+        return desc[:300]
+
+    parts = [desc]
+    if hashtags:
+        parts.append("\n\n" + hashtag_str)
+    if platform in ("youtube", "facebook"):
+        parts.append("\n\nListen to the full episode: lukeattheroost.com")
+    return "".join(parts)
+
+
+def build_settings(clip: dict, platform: str) -> dict:
+    if platform == "instagram":
+        return {"__type": "instagram", "post_type": "post", "collaborators": []}
+    if platform == "youtube":
+        yt_tags = [{"value": h.lstrip("#"), "label": h.lstrip("#")}
+                   for h in clip.get("hashtags", [])]
+        return {
+            "__type": "youtube",
+            "title": clip["title"],
+            "type": "public",
+            "selfDeclaredMadeForKids": "no",
+            "thumbnail": None,
+            "tags": yt_tags,
+        }
+    if platform == "tiktok":
+        return {
+            "__type": "tiktok",
+            "privacy_level": "PUBLIC_TO_EVERYONE",
+            "duet": False,
+            "stitch": False,
+            "comment": True,
+            "autoAddMusic": "no",
+            "brand_content_toggle": False,
+            "brand_organic_toggle": False,
+            "content_posting_method": "DIRECT_POST",
+        }
+    return {"__type": platform}
+
+
+def post_to_bluesky(clip: dict, clip_file: Path) -> bool:
+    """Post a clip directly to Bluesky via atproto (bypasses Postiz)."""
+    import time
+    import httpx
+    from atproto import models
+
+    if not BSKY_APP_PASSWORD:
+        print("    Error: BSKY_APP_PASSWORD not set in .env")
+        return False
+
+    client = BskyClient()
+    client.login(BSKY_HANDLE, BSKY_APP_PASSWORD)
+    did = client.me.did
+    video_data = clip_file.read_bytes()
+
+    # Get a service auth token scoped to the user's PDS (required by video service)
+    from urllib.parse import urlparse
+    pds_host = urlparse(client._session.pds_endpoint).hostname
+    service_auth = client.com.atproto.server.get_service_auth(
+        {"aud": f"did:web:{pds_host}", "lxm": "com.atproto.repo.uploadBlob"}
+    )
+    token = service_auth.token
+
+    # Upload video to Bluesky's video processing service (not the PDS)
+    print(f"    Uploading video ({len(video_data) / 1_000_000:.1f} MB)...")
+    upload_resp = httpx.post(
+        "https://video.bsky.app/xrpc/app.bsky.video.uploadVideo",
+        params={"did": did, "name": clip_file.name},
+        headers={
+            "Authorization": f"Bearer {token}",
+            "Content-Type": "video/mp4",
+        },
+        content=video_data,
+        timeout=120,
+    )
+    if upload_resp.status_code not in (200, 409):
+        print(f"    Upload failed: {upload_resp.status_code} {upload_resp.text[:200]}")
+        return False
+
+    upload_data = upload_resp.json()
+    job_id = upload_data.get("jobId") or upload_data.get("jobStatus", {}).get("jobId")
+    if not job_id:
+        print(f"    No jobId returned: {upload_resp.text[:200]}")
+        return False
+    print(f"    Video processing (job {job_id})...")
+
+    # Poll until video is processed
+    session_token = client._session.access_jwt
+    blob = None
+    while True:
+        status_resp = httpx.get(
+            "https://video.bsky.app/xrpc/app.bsky.video.getJobStatus",
+            params={"jobId": job_id},
+            headers={"Authorization": f"Bearer {session_token}"},
+            timeout=15,
+        )
+        resp_data = status_resp.json()
+        status = resp_data.get("jobStatus") or resp_data
+        state = status.get("state")
+        if state == "JOB_STATE_COMPLETED":
+            blob = status.get("blob")
+            break
+        if state == "JOB_STATE_FAILED":
+            err = status.get("error") or status.get("message") or "unknown"
+            print(f"    Video processing failed: {err}")
+            return False
+        progress = status.get("progress", 0)
+        print(f"    Processing... {progress}%")
+        time.sleep(3)
+
+    if not blob:
+        print("    No blob returned after processing")
+        return False
+
+    text = build_content(clip, "bluesky")
+
+    embed = models.AppBskyEmbedVideo.Main(
+        video=models.blob_ref.BlobRef(
+            mime_type=blob["mimeType"],
+            size=blob["size"],
+            ref=models.blob_ref.IpldLink(link=blob["ref"]["$link"]),
+        ),
+        alt=clip.get("caption_text", clip["title"]),
+        aspect_ratio=models.AppBskyEmbedDefs.AspectRatio(width=1080, height=1920),
+    )
+    client.send_post(text=text, embed=embed)
+    return True
+
+
+def get_youtube_service():
+    """Authenticate with YouTube API. First run opens a browser, then reuses saved token."""
+    from google.oauth2.credentials import Credentials
+    from google_auth_oauthlib.flow import InstalledAppFlow
+    from google.auth.transport.requests import Request
+    from googleapiclient.discovery import build as yt_build
+
+    scopes = ["https://www.googleapis.com/auth/youtube.upload"]
+    creds = None
+
+    if YT_TOKEN_FILE.exists():
+        creds = Credentials.from_authorized_user_file(str(YT_TOKEN_FILE), scopes)
+
+    if not creds or not creds.valid:
+        if creds and creds.expired and creds.refresh_token:
+            creds.refresh(Request())
+        else:
+            if not YT_CLIENT_SECRETS.exists():
+                print("    Error: youtube_client_secrets.json not found")
+                print("    Download OAuth2 Desktop App credentials from Google Cloud Console")
+                return None
+            flow = InstalledAppFlow.from_client_secrets_file(str(YT_CLIENT_SECRETS), scopes)
+            creds = flow.run_local_server(port=8090)
+
+        with open(YT_TOKEN_FILE, "w") as f:
+            f.write(creds.to_json())
+
+    return yt_build("youtube", "v3", credentials=creds)
+
+
+def post_to_youtube(clip: dict, clip_file: Path) -> bool:
+    """Upload a clip directly to YouTube Shorts via the Data API."""
+    import time
+    import random
+    from googleapiclient.http import MediaFileUpload
+    from googleapiclient.errors import HttpError
+
+    youtube = get_youtube_service()
+    if not youtube:
+        return False
+
+    title = clip["title"]
+    if "#Shorts" not in title:
+        title = f"{title} #Shorts"
+
+    description = build_content(clip, "youtube")
+    if "#Shorts" not in description:
+        description += "\n\n#Shorts"
+
+    tags = [h.lstrip("#") for h in clip.get("hashtags", [])]
+    if "Shorts" not in tags:
+        tags.insert(0, "Shorts")
+
+    body = {
+        "snippet": {
+            "title": title[:100],
+            "description": description,
+            "tags": tags,
+            "categoryId": "24",  # Entertainment
+        },
+        "status": {
+            "privacyStatus": "public",
+            "selfDeclaredMadeForKids": False,
+        },
+    }
+
+    media = MediaFileUpload(
+        str(clip_file),
+        mimetype="video/mp4",
+        chunksize=256 * 1024,
+        resumable=True,
+    )
+
+    request = youtube.videos().insert(part="snippet,status", body=body, media_body=media)
+
+    file_size = clip_file.stat().st_size / 1_000_000
+    print(f"    Uploading video ({file_size:.1f} MB)...")
+
+    response = None
+    retry = 0
+    while response is None:
+        try:
+            status, response = request.next_chunk()
+            if status:
+                print(f"    Upload {int(status.progress() * 100)}%...")
+        except HttpError as e:
+            if e.resp.status in (500, 502, 503, 504) and retry < 5:
+                retry += 1
+                wait = random.random() * (2 ** retry)
+                print(f"    Retrying in {wait:.1f}s...")
+                time.sleep(wait)
+            else:
+                print(f"    YouTube API error: {e}")
+                return False
+
+    video_id = response["id"]
+    print(f"    https://youtube.com/shorts/{video_id}")
+    return video_id
+
+
+def create_post(integration_id: str, content: str, media: dict,
+                settings: dict, schedule: str | None = None) -> dict:
+    from datetime import datetime, timezone
+    post_type = "schedule" if schedule else "now"
+    date = schedule or datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.000Z")
+    payload = {
+        "type": post_type,
+        "date": date,
+        "shortLink": False,
+        "tags": [],
+        "posts": [
+            {
+                "integration": {"id": integration_id},
+                "value": [
+                    {
+                        "content": content,
+                        "image": [media] if media else [],
+                    }
+                ],
+                "settings": settings,
+            }
+        ],
+    }
+
+    resp = requests.post(
+        get_api_url("/posts"),
+        headers=api_headers(),
+        json=payload,
+        timeout=30,
+    )
+    if resp.status_code not in (200, 201):
+        print(f"Post creation failed: {resp.status_code} {resp.text[:300]}")
+        return {}
+    return resp.json()
+
+
+def main():
+    valid_names = sorted(set(PLATFORM_ALIASES.keys()))
+    parser = argparse.ArgumentParser(description="Upload podcast clips to social media via Postiz")
+    parser.add_argument("clips_dir", nargs="?", help="Path to clips directory (e.g. clips/episode-12/). If omitted, shows a picker.")
+    parser.add_argument("--clip", "-c", type=int, help="Upload only clip N (1-indexed)")
+    parser.add_argument("--platforms", "-p",
+                        help=f"Comma-separated platforms ({','.join(ALL_PLATFORMS)}). Default: all")
+    parser.add_argument("--schedule", "-s", help="Schedule time (ISO 8601, e.g. 2026-02-16T10:00:00)")
+    parser.add_argument("--yes", "-y", action="store_true", help="Skip confirmation prompt")
+    parser.add_argument("--dry-run", action="store_true", help="Show what would be uploaded without posting")
+    args = parser.parse_args()
+
+    if not POSTIZ_API_KEY:
+        print("Error: POSTIZ_API_KEY not set in .env")
+        sys.exit(1)
+
+    # Resolve clips directory — pick interactively if not provided
+    if args.clips_dir:
+        clips_dir = Path(args.clips_dir).expanduser().resolve()
+    else:
+        clips_root = Path(__file__).parent / "clips"
+        episode_dirs = sorted(
+            [d for d in clips_root.iterdir()
+             if d.is_dir() and not d.name.startswith(".") and (d / "clips-metadata.json").exists()],
+            key=lambda d: (int(m.group(1)) if (m := re.search(r'(\d+)', d.name)) else 0, d.name),
+        )
+        if not episode_dirs:
+            print("No clip directories found in clips/. Run make_clips.py first.")
+            sys.exit(1)
+        print("\nAvailable episodes:\n")
+        for i, d in enumerate(episode_dirs):
+            with open(d / "clips-metadata.json") as f:
+                meta = json.load(f)
+            print(f"  {i+1}. {d.name} ({len(meta)} clip{'s' if len(meta) != 1 else ''})")
+        print()
+        while True:
+            try:
+                choice = input("Which episode? ").strip()
+                idx = int(choice) - 1
+                if 0 <= idx < len(episode_dirs):
+                    clips_dir = episode_dirs[idx]
+                    break
+                print(f"  Enter 1-{len(episode_dirs)}")
+            except (ValueError, EOFError):
+                print(f"  Enter an episode number")
+
+    metadata_path = clips_dir / "clips-metadata.json"
+    if not metadata_path.exists():
+        print(f"Error: No clips-metadata.json found in {clips_dir}")
+        print("Run make_clips.py first to generate clips and metadata.")
+        sys.exit(1)
+
+    with open(metadata_path) as f:
+        clips = json.load(f)
+
+    # Pick clips
+    if args.clip:
+        if args.clip < 1 or args.clip > len(clips):
+            print(f"Error: Clip {args.clip} not found (have {len(clips)} clips)")
+            sys.exit(1)
+        clips = [clips[args.clip - 1]]
+    elif not args.yes:
+        print(f"\nFound {len(clips)} clip(s):\n")
+        for i, clip in enumerate(clips):
+            desc = clip.get('description', clip.get('caption_text', ''))
+            if len(desc) > 70:
+                desc = desc[:desc.rfind(' ', 0, 70)] + '...'
+            print(f"  {i+1}. \"{clip['title']}\" ({clip['duration']:.0f}s)")
+            print(f"     {desc}")
+        print(f"\n  a. All clips")
+        print()
+        while True:
+            choice = input("Which clips? (e.g. 1,3 or a for all): ").strip().lower()
+            if choice in ('a', 'all'):
+                break
+            try:
+                indices = [int(x.strip()) for x in choice.split(",")]
+                if all(1 <= x <= len(clips) for x in indices):
+                    clips = [clips[x - 1] for x in indices]
+                    break
+                print(f"  Invalid selection. Enter 1-{len(clips)}, comma-separated, or 'a' for all.")
+            except (ValueError, EOFError):
+                print(f"  Enter clip numbers (e.g. 1,3) or 'a' for all")
+
+    # Pick platforms
+    if args.platforms:
+        requested = []
+        for p in args.platforms.split(","):
+            p = p.strip().lower()
+            if p not in PLATFORM_ALIASES:
+                print(f"Unknown platform: {p}")
+                print(f"Valid: {', '.join(valid_names)}")
+                sys.exit(1)
+            requested.append(PLATFORM_ALIASES[p])
+        target_platforms = list(dict.fromkeys(requested))
+    elif not args.yes:
+        print(f"\nPlatforms:\n")
+        for i, p in enumerate(ALL_PLATFORMS):
+            print(f"  {i+1}. {PLATFORM_DISPLAY[p]}")
+        print(f"\n  a. All platforms (default)")
+        print()
+        choice = input("Which platforms? (e.g. 1,3,5 or a for all) [a]: ").strip().lower()
+        if choice and choice not in ('a', 'all'):
+            try:
+                indices = [int(x.strip()) for x in choice.split(",")]
+                target_platforms = [ALL_PLATFORMS[x - 1] for x in indices if 1 <= x <= len(ALL_PLATFORMS)]
+                if not target_platforms:
+                    target_platforms = ALL_PLATFORMS[:]
+            except (ValueError, IndexError):
+                target_platforms = ALL_PLATFORMS[:]
+        else:
+            target_platforms = ALL_PLATFORMS[:]
+    else:
+        target_platforms = ALL_PLATFORMS[:]
+
+    DIRECT_PLATFORMS = {"bluesky", "youtube"}
+    needs_postiz = not args.dry_run and any(
+        p not in DIRECT_PLATFORMS for p in target_platforms)
+    if needs_postiz:
+        print("Fetching connected accounts from Postiz...")
+        integrations = fetch_integrations()
+    else:
+        integrations = []
+
+    active_platforms = {}
+    for platform in target_platforms:
+        if platform == "bluesky":
+            if BSKY_APP_PASSWORD or args.dry_run:
+                active_platforms[platform] = {"name": BSKY_HANDLE, "_direct": True}
+            else:
+                print("Warning: BSKY_APP_PASSWORD not set in .env, skipping Bluesky")
+            continue
+        if platform == "youtube":
+            if YT_CLIENT_SECRETS.exists() or YT_TOKEN_FILE.exists() or args.dry_run:
+                active_platforms[platform] = {"name": "YouTube Shorts", "_direct": True}
+            else:
+                print("Warning: youtube_client_secrets.json not found, skipping YouTube")
+            continue
+        if args.dry_run:
+            active_platforms[platform] = {"name": PLATFORM_DISPLAY[platform]}
+            continue
+        integ = find_integration(integrations, platform)
+        if integ:
+            active_platforms[platform] = integ
+        else:
+            print(f"Warning: No {PLATFORM_DISPLAY[platform]} account connected in Postiz")
+
+    if not args.dry_run and not active_platforms:
+        print("Error: No platforms available to upload to")
+        sys.exit(1)
+
+    platform_names = [f"{PLATFORM_DISPLAY[p]} ({integ.get('name', 'connected')})"
+                      for p, integ in active_platforms.items()]
+
+    print(f"\nUploading {len(clips)} clip(s) to: {', '.join(platform_names)}")
+    if args.schedule:
+        print(f"Scheduled for: {args.schedule}")
+    print()
+
+    for i, clip in enumerate(clips):
+        print(f"  {i+1}. \"{clip['title']}\" ({clip['duration']:.0f}s)")
+        desc = clip.get('description', '')
+        if len(desc) > 80:
+            desc = desc[:desc.rfind(' ', 0, 80)] + '...'
+        print(f"     {desc}")
+        print(f"     {' '.join(clip.get('hashtags', []))}")
+        print()
+
+    if args.dry_run:
+        print("Dry run — nothing uploaded.")
+        return
+
+    if not args.yes:
+        confirm = input("Proceed? [y/N] ").strip().lower()
+        if confirm != "y":
+            print("Cancelled.")
+            return
+
+    upload_history = load_upload_history(clips_dir)
+
+    for i, clip in enumerate(clips):
+        clip_file = clips_dir / clip["clip_file"]
+        if not clip_file.exists():
+            print(f"  Clip {i+1}: Video file not found: {clip_file}")
+            continue
+
+        clip_key = clip["clip_file"]
+        already_uploaded = set(upload_history.get(clip_key, []))
+        remaining_platforms = {p: integ for p, integ in active_platforms.items()
+                               if p not in already_uploaded}
+
+        if not remaining_platforms:
+            print(f"\n  Clip {i+1}: \"{clip['title']}\" — already uploaded to all selected platforms, skipping")
+            continue
+
+        skipped = already_uploaded & set(active_platforms.keys())
+        if skipped:
+            print(f"\n  Clip {i+1}: \"{clip['title']}\" (skipping already uploaded: {', '.join(sorted(skipped))})")
+        else:
+            print(f"\n  Clip {i+1}: \"{clip['title']}\"")
+
+        postiz_platforms = {p: integ for p, integ in remaining_platforms.items()
+                            if not integ.get("_direct")}
+
+        media = None
+        if postiz_platforms:
+            print(f"    Uploading {clip_file.name}...")
+            media = upload_file(clip_file)
+            if not media:
+                print("    Failed to upload video to Postiz, skipping Postiz platforms")
+                postiz_platforms = {}
+            else:
+                print(f"    Uploaded: {media.get('path', 'ok')}")
+
+        for platform, integ in postiz_platforms.items():
+            display = PLATFORM_DISPLAY[platform]
+            print(f"    Posting to {display}...")
+            content = build_content(clip, platform)
+            settings = build_settings(clip, platform)
+            result = create_post(integ["id"], content, media, settings, args.schedule)
+            if result:
+                print(f"    {display}: Posted!")
+                upload_history.setdefault(clip_key, []).append(platform)
+                save_upload_history(clips_dir, upload_history)
+            else:
+                print(f"    {display}: Failed")
+
+        if "youtube" in remaining_platforms:
+            print(f"    Posting to YouTube Shorts (direct)...")
+            try:
+                yt_video_id = post_to_youtube(clip, clip_file)
+                if yt_video_id:
+                    print(f"    YouTube: Posted!")
+                    upload_history.setdefault(clip_key, []).append("youtube")
+                    save_upload_history(clips_dir, upload_history)
+                else:
+                    print(f"    YouTube: Failed")
+            except Exception as e:
+                print(f"    YouTube: Failed — {e}")
+
+        if "bluesky" in remaining_platforms:
+            print(f"    Posting to Bluesky (direct)...")
+            try:
+                if post_to_bluesky(clip, clip_file):
+                    print(f"    Bluesky: Posted!")
+                    upload_history.setdefault(clip_key, []).append("bluesky")
+                    save_upload_history(clips_dir, upload_history)
+                else:
+                    print(f"    Bluesky: Failed")
+            except Exception as e:
+                print(f"    Bluesky: Failed — {e}")
+
+    # Sync clips to website if any YouTube uploads happened
+    if "youtube" in active_platforms:
+        sync_clips_to_website()
+
+    print("\nDone!")
+
+
+WEBSITE_DIR = Path(__file__).parent / "website"
+CLIPS_JSON = WEBSITE_DIR / "data" / "clips.json"
+THUMBS_DIR = WEBSITE_DIR / "images" / "clips"
+CLIPS_ROOT = Path(__file__).parent / "clips"
+
+
+def sync_clips_to_website():
+    """Rebuild website/data/clips.json from YouTube shorts and deploy."""
+    import subprocess
+
+    print("\nSyncing clips to website...")
+
+    # Fetch all YouTube shorts from channel
+    result = subprocess.run(
+        ["python3", "-m", "yt_dlp", "--flat-playlist", "--print", "%(id)s\t%(title)s",
+         "https://www.youtube.com/lukemacneil/shorts"],
+        capture_output=True, text=True, timeout=60,
+    )
+    if not result.stdout.strip():
+        print("  Could not fetch YouTube shorts, skipping sync")
+        return
+
+    yt_shorts = {}
+    for line in result.stdout.strip().split("\n"):
+        if "\t" not in line:
+            continue
+        vid_id, title = line.split("\t", 1)
+        clean_title = re.sub(r"\s*#Shorts\s*$", "", title).strip().lower()
+        yt_shorts[clean_title] = vid_id
+
+    print(f"  Found {len(yt_shorts)} YouTube shorts")
+
+    # Load all clip metadata and match to YouTube
+    existing = {}
+    if CLIPS_JSON.exists():
+        for c in json.loads(CLIPS_JSON.read_text()):
+            existing[c["clip_file"]] = c
+
+    new_clips = []
+    for ep_dir in sorted(CLIPS_ROOT.glob("episode-*")):
+        meta_file = ep_dir / "clips-metadata.json"
+        if not meta_file.exists():
+            continue
+        for clip in json.loads(meta_file.read_text()):
+            clip_title = clip["title"].strip().lower()
+            yt_id = yt_shorts.get(clip_title, "")
+            if not yt_id:
+                for yt_title, yid in yt_shorts.items():
+                    if yt_title in clip_title or clip_title in yt_title:
+                        yt_id = yid
+                        break
+            if not yt_id:
+                continue
+
+            prev = existing.get(clip["clip_file"], {})
+            new_clips.append({
+                "title": clip["title"],
+                "description": clip.get("description", clip.get("caption_text", "")),
+                "episode_number": clip.get("episode_number", 0),
+                "clip_file": clip["clip_file"],
+                "youtube_id": yt_id,
+                "featured": prev.get("featured", False),
+                "thumbnail": prev.get("thumbnail", ""),
+            })
+
+    new_clips.sort(key=lambda c: c["episode_number"], reverse=True)
+
+    # Generate thumbnails for clips that don't have one
+    THUMBS_DIR.mkdir(parents=True, exist_ok=True)
+    for clip in new_clips:
+        if clip["thumbnail"]:
+            thumb_path = WEBSITE_DIR / clip["thumbnail"]
+            if thumb_path.exists():
+                continue
+
+        thumb_name = clip["clip_file"].replace(".mp4", ".jpg")
+        thumb_path = THUMBS_DIR / thumb_name
+        ep_num = clip["episode_number"]
+        mp4_path = CLIPS_ROOT / f"episode-{ep_num}" / clip["clip_file"]
+
+        if not mp4_path.exists():
+            continue
+
+        subprocess.run(
+            ["ffmpeg", "-y", "-i", str(mp4_path), "-ss", "3", "-vframes", "1",
+             "-update", "1", "-vf", "scale=360:-2", "-q:v", "4", str(thumb_path)],
+            capture_output=True, timeout=30,
+        )
+        if thumb_path.exists():
+            clip["thumbnail"] = f"images/clips/{thumb_name}"
+            print(f"  Generated thumbnail: {thumb_name}")
+
+    # Ensure at least 3 featured
+    featured_count = sum(1 for c in new_clips if c.get("featured"))
+    if featured_count < 3:
+        for c in new_clips:
+            if not c.get("featured"):
+                c["featured"] = True
+                featured_count += 1
+                if featured_count >= 3:
+                    break
+
+    CLIPS_JSON.parent.mkdir(parents=True, exist_ok=True)
+    CLIPS_JSON.write_text(json.dumps(new_clips, indent=2))
+    print(f"  Updated clips.json: {len(new_clips)} clips")
+
+    # Deploy
+    print("  Deploying website...")
+    deploy = subprocess.run(
+        ["npx", "wrangler", "pages", "deploy", "website/",
+         "--project-name=lukeattheroost", "--branch=main", "--commit-dirty=true"],
+        capture_output=True, text=True, timeout=120,
+        cwd=str(Path(__file__).parent),
+    )
+    if "Deployment complete" in deploy.stdout:
+        print("  Website deployed!")
+    else:
+        print(f"  Deploy failed: {deploy.stderr[-300:]}")
+
+
+if __name__ == "__main__":
+    main()

website/404.html

@@ -0,0 +1,52 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Page Not Found — Luke at the Roost</title>
+  <meta name="description" content="The page you're looking for doesn't exist.">
+  <meta name="theme-color" content="#1a1209">
+
+  <link rel="icon" href="favicon.ico" sizes="48x48">
+  <link rel="icon" type="image/svg+xml" href="favicon.svg">
+  <link rel="icon" type="image/png" sizes="192x192" href="favicon-192.png">
+  <link rel="icon" type="image/png" sizes="48x48" href="favicon-48.png">
+  <link rel="icon" type="image/png" sizes="32x32" href="favicon-32.png">
+  <link rel="icon" type="image/png" sizes="16x16" href="favicon-16.png">
+  <link rel="apple-touch-icon" href="apple-touch-icon.png">
+
+  <link rel="stylesheet" href="css/style.css?v=5">
+  <script defer data-domain="lukeattheroost.com" data-api="/p/event" src="/p/script"></script>
+  <script>window.plausible = window.plausible || function() { (window.plausible.q = window.plausible.q || []).push(arguments) }</script>
+</head>
+<body>
+
+  <a href="#main-content" class="skip-link">Skip to content</a>
+
+  <nav class="site-nav">
+    <a href="/" class="site-nav-brand">Luke at the Roost</a>
+    <div class="site-nav-links">
+      <a href="/how-it-works">How It Works</a>
+      <a href="/clips">Clips</a>
+      <a href="/stats">Stats</a>
+    </div>
+  </nav>
+
+  <main id="main-content">
+
+  <section class="page-header">
+    <h1>404 — Page Not Found</h1>
+    <p class="page-subtitle">Looks like this page wandered off into the desert.</p>
+  </section>
+
+  <section class="about-section">
+    <p>The page you're looking for doesn't exist or may have been moved.</p>
+    <p><a href="/">Back to the show</a> &middot; <a href="/clips">Watch clips</a> &middot; <a href="/how-it-works">How it works</a></p>
+  </section>
+
+  </main>
+
+  <footer class="footer"></footer>
+  <script src="js/footer.js"></script>
+</body>
+</html>

website/_redirects

@@ -0,0 +1 @@
+/episodes.html /episode 302

website/_worker.js

@@ -0,0 +1,153 @@
+const VOICEMAIL_XML = `<?xml version="1.0" encoding="UTF-8"?>
+<Response>
+    <Say voice="woman">Luke at the Roost is off the air right now. Leave a message after the beep and we may play it on the next show!</Say>
+    <Record maxLength="120" action="https://radioshow.macneilmediagroup.com/api/signalwire/voicemail-complete" playBeep="true" />
+    <Say voice="woman">Thank you for calling. Goodbye!</Say>
+    <Hangup/>
+</Response>`;
+
+export default {
+  async fetch(request, env) {
+    const url = new URL(request.url);
+
+    if (url.pathname === "/api/signalwire/voice") {
+      try {
+        const body = await request.text();
+        const resp = await fetch("https://radioshow.macneilmediagroup.com/api/signalwire/voice", {
+          method: "POST",
+          headers: { "Content-Type": "application/x-www-form-urlencoded" },
+          body: body,
+          signal: AbortSignal.timeout(5000),
+        });
+
+        if (resp.ok) {
+          return new Response(await resp.text(), {
+            status: 200,
+            headers: { "Content-Type": "application/xml" },
+          });
+        }
+      } catch (e) {
+        // Server unreachable or timed out
+      }
+
+      return new Response(VOICEMAIL_XML, {
+        status: 200,
+        headers: { "Content-Type": "application/xml" },
+      });
+    }
+
+    // RSS feed proxy
+    if (url.pathname === "/feed") {
+      try {
+        const resp = await fetch("https://podcast.macneilmediagroup.com/@LukeAtTheRoost/feed.xml", {
+          signal: AbortSignal.timeout(8000),
+        });
+        if (resp.ok) {
+          return new Response(await resp.text(), {
+            status: 200,
+            headers: {
+              "Content-Type": "application/xml",
+              "Access-Control-Allow-Origin": "*",
+              "Cache-Control": "public, max-age=300",
+            },
+          });
+        }
+      } catch (e) {
+        // Castopod unreachable
+      }
+      return new Response("Feed unavailable", { status: 502 });
+    }
+
+    // Plausible analytics proxy (bypass ad blockers)
+    if (url.pathname === "/p/script") {
+      const resp = await fetch("https://plausible.macneilmediagroup.com/js/script.file-downloads.hash.outbound-links.pageview-props.revenue.tagged-events.js");
+      return new Response(await resp.text(), {
+        headers: {
+          "Content-Type": "application/javascript",
+          "Cache-Control": "public, max-age=86400",
+        },
+      });
+    }
+
+    if (url.pathname === "/p/event" && request.method === "POST") {
+      const body = await request.text();
+      const resp = await fetch("https://plausible.macneilmediagroup.com/api/event", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "User-Agent": request.headers.get("User-Agent") || "",
+          "X-Forwarded-For": request.headers.get("CF-Connecting-IP") || request.headers.get("X-Forwarded-For") || "",
+        },
+        body,
+      });
+      return new Response(resp.body, {
+        status: resp.status,
+        headers: { "Content-Type": resp.headers.get("Content-Type") || "text/plain" },
+      });
+    }
+
+    // Social crawler meta injection for episode pages
+    if (url.pathname === "/episode.html" && url.searchParams.get("slug")) {
+      const ua = (request.headers.get("User-Agent") || "").toLowerCase();
+      const isCrawler = /facebookexternalhit|twitterbot|linkedinbot|slackbot|discordbot|telegrambot|whatsapp|pinterest|redditbot/i.test(ua);
+
+      if (isCrawler) {
+        const slug = url.searchParams.get("slug");
+        try {
+          const feedResp = await fetch("https://podcast.macneilmediagroup.com/@LukeAtTheRoost/feed.xml", {
+            signal: AbortSignal.timeout(5000),
+          });
+          if (feedResp.ok) {
+            const feedXml = await feedResp.text();
+            const items = feedXml.split("<item>");
+            let title = "";
+            let description = "";
+
+            for (let i = 1; i < items.length; i++) {
+              const item = items[i];
+              const linkMatch = item.match(/<link>(.*?)<\/link>/);
+              if (linkMatch) {
+                const itemSlug = linkMatch[1].split("/episodes/").pop()?.replace(/\/$/, "");
+                if (itemSlug === slug) {
+                  const titleMatch = item.match(/<title>(.*?)<\/title>/);
+                  title = titleMatch ? titleMatch[1].replace(/<!\[CDATA\[|\]\]>/g, "").trim() : "";
+                  const descMatch = item.match(/<description>([\s\S]*?)<\/description>/);
+                  description = descMatch
+                    ? descMatch[1].replace(/<!\[CDATA\[|\]\]>/g, "").replace(/<[^>]+>/g, "").trim().slice(0, 200)
+                    : "";
+                  break;
+                }
+              }
+            }
+
+            if (title) {
+              const pageResp = await env.ASSETS.fetch(request);
+              let html = await pageResp.text();
+
+              const escTitle = title.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;");
+              const escDesc = description.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;");
+              const canonicalUrl = `https://lukeattheroost.com/episode.html?slug=${slug}`;
+
+              html = html.replace(/<meta property="og:title"[^>]*>/, `<meta property="og:title" content="${escTitle}">`);
+              html = html.replace(/<meta property="og:description"[^>]*>/, `<meta property="og:description" content="${escDesc}">`);
+              html = html.replace(/<meta property="og:url"[^>]*>/, `<meta property="og:url" content="${canonicalUrl}">`);
+              html = html.replace(/<meta name="twitter:title"[^>]*>/, `<meta name="twitter:title" content="${escTitle}">`);
+              html = html.replace(/<meta name="twitter:description"[^>]*>/, `<meta name="twitter:description" content="${escDesc}">`);
+              html = html.replace(/<title[^>]*>.*?<\/title>/, `<title>${escTitle} — Luke at the Roost</title>`);
+
+              return new Response(html, {
+                status: 200,
+                headers: { "Content-Type": "text/html;charset=UTF-8" },
+              });
+            }
+          }
+        } catch (e) {
+          // Fall through to static page
+        }
+      }
+    }
+
+    // All other requests — serve static assets
+    return env.ASSETS.fetch(request);
+  },
+};

website/clips.html

@@ -0,0 +1,83 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Clips — Luke at the Roost</title>
+  <meta name="description" content="The best moments from Luke at the Roost — watch clips from the AI call-in comedy podcast.">
+  <meta name="theme-color" content="#1a1209">
+  <link rel="canonical" href="https://lukeattheroost.com/clips">
+
+  <meta property="og:site_name" content="Luke at the Roost">
+  <meta property="og:title" content="Clips — Luke at the Roost">
+  <meta property="og:description" content="The best moments from Luke at the Roost — watch clips from the AI call-in comedy podcast.">
+  <meta property="og:image" content="https://cdn.lukeattheroost.com/media/podcasts/LukeAtTheRoost/cover_feed.png?v=3">
+  <meta property="og:url" content="https://lukeattheroost.com/clips">
+  <meta property="og:type" content="website">
+  <meta name="twitter:card" content="summary_large_image">
+  <meta name="twitter:title" content="Clips — Luke at the Roost">
+  <meta name="twitter:description" content="The best moments from Luke at the Roost — watch clips from the AI call-in comedy podcast.">
+  <meta name="twitter:image" content="https://cdn.lukeattheroost.com/media/podcasts/LukeAtTheRoost/cover_feed.png?v=3">
+
+  <link rel="icon" href="favicon.ico" sizes="48x48">
+  <link rel="icon" type="image/svg+xml" href="favicon.svg">
+  <link rel="icon" type="image/png" sizes="192x192" href="favicon-192.png">
+  <link rel="icon" type="image/png" sizes="48x48" href="favicon-48.png">
+  <link rel="icon" type="image/png" sizes="32x32" href="favicon-32.png">
+  <link rel="icon" type="image/png" sizes="16x16" href="favicon-16.png">
+  <link rel="apple-touch-icon" href="apple-touch-icon.png">
+
+  <script type="application/ld+json">
+  {
+    "@context": "https://schema.org",
+    "@type": "BreadcrumbList",
+    "itemListElement": [
+      { "@type": "ListItem", "position": 1, "name": "Home", "item": "https://lukeattheroost.com" },
+      { "@type": "ListItem", "position": 2, "name": "Clips" }
+    ]
+  }
+  </script>
+
+  <link rel="alternate" type="application/rss+xml" title="Luke at the Roost RSS Feed" href="https://podcast.macneilmediagroup.com/@LukeAtTheRoost/feed.xml">
+  <link rel="stylesheet" href="css/style.css?v=5">
+    <script defer data-domain="lukeattheroost.com" data-api="/p/event" src="/p/script"></script>
+    <script>window.plausible = window.plausible || function() { (window.plausible.q = window.plausible.q || []).push(arguments) }</script>
+</head>
+<body>
+
+  <a href="#main-content" class="skip-link">Skip to content</a>
+
+  <nav class="site-nav">
+    <a href="/" class="site-nav-brand">Luke at the Roost</a>
+    <div class="site-nav-links">
+      <a href="/how-it-works">How It Works</a>
+      <a href="/clips" aria-current="page">Clips</a>
+      <a href="/stats">Stats</a>
+    </div>
+  </nav>
+
+  <main id="main-content">
+
+  <section class="page-header">
+    <h1>Clips</h1>
+    <p class="page-subtitle">The best moments from the show</p>
+  </section>
+
+  <div class="clips-section-header">
+    <h2>Featured</h2>
+  </div>
+  <section class="clips-featured"></section>
+
+  <div class="clips-section-header">
+    <h2>All Clips</h2>
+  </div>
+  <section class="clips-grid"></section>
+
+  </main>
+
+  <footer class="footer"></footer>
+
+  <script src="js/footer.js"></script>
+  <script src="js/clips.js"></script>
+</body>
+</html>

website/data/clips.json

@@ -0,0 +1,245 @@
+[
+  {
+    "title": "Cult Leader Realizes He's Been Manipulating People",
+    "description": "Cult leader calls in having a full existential crisis about his 'shared intimacy nights' and the manipulation tactics he's been using on his followers.",
+    "episode_number": 37,
+    "clip_file": "clip-3-cult-leader-realizes-he-s-been-manipulating-people.mp4",
+    "youtube_id": "zmCfOQuXtBE",
+    "featured": false,
+    "thumbnail": "images/clips/clip-3-cult-leader-realizes-he-s-been-manipulating-people.jpg"
+  },
+  {
+    "title": "Intern Pitches Himself Live On Air",
+    "description": "This intern used his first day on the job to shoot his shot with the entire radio audience. The therapy line is sending me.",
+    "episode_number": 36,
+    "clip_file": "clip-1-intern-pitches-himself-live-on-air.mp4",
+    "youtube_id": "exO3_9ewKH0",
+    "featured": false,
+    "thumbnail": "images/clips/clip-1-intern-pitches-himself-live-on-air.jpg"
+  },
+  {
+    "title": "Wait Until She Dies or Kill Her",
+    "description": "Luke gives the most UNHINGED inheritance advice I've ever heard on live radio. This escalated so fast.",
+    "episode_number": 35,
+    "clip_file": "clip-1-wait-until-she-dies-or-kill-her.mp4",
+    "youtube_id": "03oJoRh-ioo",
+    "featured": false,
+    "thumbnail": "images/clips/clip-1-wait-until-she-dies-or-kill-her.jpg"
+  },
+  {
+    "title": "Nobody's Potato Salad Is Good",
+    "description": "Luke goes OFF on workplace potlucks: 'Nobody's potato salad is f***ing good, alright? Everything at a potluck is gross. Just take everybody to McDonald's.'",
+    "episode_number": 34,
+    "clip_file": "clip-3-nobody-s-potato-salad-is-good.mp4",
+    "youtube_id": "re7C2woMUrA",
+    "featured": false,
+    "thumbnail": "images/clips/clip-3-nobody-s-potato-salad-is-good.jpg"
+  },
+  {
+    "title": "Man Obsessed With Dead Nun Loses Wife",
+    "description": "Rodney couldn't stop talking about a dead nun who shared his wife's name. His wife was NOT amused.",
+    "episode_number": 33,
+    "clip_file": "clip-1-man-obsessed-with-dead-nun-loses-wife.mp4",
+    "youtube_id": "zD8CdX7s8us",
+    "featured": false,
+    "thumbnail": "images/clips/clip-1-man-obsessed-with-dead-nun-loses-wife.jpg"
+  },
+  {
+    "title": "I Faked Cancer to Skip a Wedding",
+    "description": "A small lie to skip his sister's FOURTH wedding spiraled into a GoFundMe, a pancake breakfast fundraiser, and a $4,700 check. Now he's in too deep.",
+    "episode_number": 32,
+    "clip_file": "clip-1-i-faked-cancer-to-skip-a-wedding.mp4",
+    "youtube_id": "NUkhsPfMx9o",
+    "featured": true,
+    "thumbnail": "images/clips/clip-1-i-faked-cancer-to-skip-a-wedding.jpg"
+  },
+  {
+    "title": "Started a Fight and Can't Stop Reading About Wars",
+    "description": "A caller starts a fight with their partner and spirals into an obsessive deep-dive on historical wars. Luke tries to untangle the connection.",
+    "episode_number": 31,
+    "clip_file": "clip-3-started-a-fight-and-can-t-stop-reading-about-wars.mp4",
+    "youtube_id": "D2iWnSGQeow",
+    "featured": false,
+    "thumbnail": "images/clips/clip-3-started-a-fight-and-can-t-stop-reading-about-wars.jpg"
+  },
+  {
+    "title": "Latex Fetish Confession Goes Silent",
+    "description": "He finally opened up about his latex fetish to his girlfriend and got 10 seconds of pure silence. Now he's wondering if honesty just cost him everything.",
+    "episode_number": 30,
+    "clip_file": "clip-3-latex-fetish-confession-goes-silent.mp4",
+    "youtube_id": "vFvWUbYacug",
+    "featured": false,
+    "thumbnail": "images/clips/clip-3-latex-fetish-confession-goes-silent.jpg"
+  },
+  {
+    "title": "Adopted Daughter Might Have Been Stolen",
+    "description": "A lawyer in Guatemala just sent him proof that his adopted daughter might have been stolen from her birth mother. The photo shows the same crooked smile and now everything is falling apart.",
+    "episode_number": 29,
+    "clip_file": "clip-3-adopted-daughter-might-have-been-stolen.mp4",
+    "youtube_id": "hMxldZN3VHw",
+    "featured": false,
+    "thumbnail": "images/clips/clip-3-adopted-daughter-might-have-been-stolen.jpg"
+  },
+  {
+    "title": "Vinyl vs Digital: The Warmth Debate",
+    "description": "Vinyl collector calls in to absolutely torch the 'warmth' argument. Turns out what you love about records might just be... imperfection.",
+    "episode_number": 28,
+    "clip_file": "clip-2-vinyl-vs-digital-the-warmth-debate.mp4",
+    "youtube_id": "aVmhApa0d2E",
+    "featured": false,
+    "thumbnail": "images/clips/clip-2-vinyl-vs-digital-the-warmth-debate.jpg"
+  },
+  {
+    "title": "Open Marriage Backfired Spectacularly",
+    "description": "She thought opening up the marriage would spice things up. He's living his best life while she can't even get a text back.",
+    "episode_number": 27,
+    "clip_file": "clip-2-open-marriage-backfired-spectacularly.mp4",
+    "youtube_id": "-K-t7iijfGs",
+    "featured": false,
+    "thumbnail": "images/clips/clip-2-open-marriage-backfired-spectacularly.jpg"
+  },
+  {
+    "title": "Neighbor's Roomba Breaks Into Kitchen at 2:30 AM",
+    "description": "She woke up at 2:30 AM to find her neighbor Gary's Roomba cleaning her kitchen. Yes, it had Gary's name on it. Yes, it came through the dog door.",
+    "episode_number": 26,
+    "clip_file": "clip-2-neighbor-s-roomba-breaks-into-kitchen-at-2-30-am.mp4",
+    "youtube_id": "J7bfT6jsykA",
+    "featured": true,
+    "thumbnail": "images/clips/clip-2-neighbor-s-roomba-breaks-into-kitchen-at-2-30-am.jpg"
+  },
+  {
+    "title": "You're a Computer-Generated AI Caller",
+    "description": "The AI caller admits it: 'You're right. I am computer-generated. And you're sitting there alone at midnight talking to me like it's real.' Luke's reaction is everything.",
+    "episode_number": 24,
+    "clip_file": "clip-10-you-re-a-computer-generated-ai-caller.mp4",
+    "youtube_id": "QVcoU59OTRA",
+    "featured": false,
+    "thumbnail": "images/clips/clip-10-you-re-a-computer-generated-ai-caller.jpg"
+  },
+  {
+    "title": "Full Banana Costume at Work Party",
+    "description": "He showed up to his manager's holiday party in a full banana costume and now HR says it shows 'lack of professional judgment.' Was it really that serious?",
+    "episode_number": 23,
+    "clip_file": "clip-4-full-banana-costume-at-work-party.mp4",
+    "youtube_id": "enyqXHxmzqA",
+    "featured": false,
+    "thumbnail": "images/clips/clip-4-full-banana-costume-at-work-party.jpg"
+  },
+  {
+    "title": "The Poison That Saved Everything",
+    "description": "The apocalypse that saved us all. 2.5 billion years ago, oxygen poisoned nearly everything on Earth\u2014and that catastrophe made life as we know it possible.",
+    "episode_number": 22,
+    "clip_file": "clip-1-the-poison-that-saved-everything.mp4",
+    "youtube_id": "BHm3RJ5YC_8",
+    "featured": false,
+    "thumbnail": "images/clips/clip-1-the-poison-that-saved-everything.jpg"
+  },
+  {
+    "title": "I Burned My Marriage for Work",
+    "description": "He burned his second marriage to the ground chasing work. His wife didn't leave because of money\u2014she left because he was never there.",
+    "episode_number": 22,
+    "clip_file": "clip-3-i-burned-my-marriage-for-work.mp4",
+    "youtube_id": "1a_9Yl-isN0",
+    "featured": false,
+    "thumbnail": "images/clips/clip-3-i-burned-my-marriage-for-work.jpg"
+  },
+  {
+    "title": "Shopping Cart Theory: Moral Test or Crazy?",
+    "description": "A caller defends the shopping cart theory by admitting they literally watch people from their workplace. Luke has some thoughts on what's actually crazy here.",
+    "episode_number": 21,
+    "clip_file": "clip-2-shopping-cart-theory-moral-test-or-crazy.mp4",
+    "youtube_id": "KijyJsMZfkA",
+    "featured": true,
+    "thumbnail": "images/clips/clip-2-shopping-cart-theory-moral-test-or-crazy.jpg"
+  },
+  {
+    "title": "Dog Takes a Shit With Leg Up",
+    "description": "This caller's dog just unlocked a new achievement that has him bursting with pride. You won't believe what had him celebrating like his pup won best in show.",
+    "episode_number": 20,
+    "clip_file": "clip-1-dog-takes-a-shit-with-leg-up.mp4",
+    "youtube_id": "SXcCrlQTuwM",
+    "featured": false,
+    "thumbnail": "images/clips/clip-1-dog-takes-a-shit-with-leg-up.jpg"
+  },
+  {
+    "title": "Don't Get Married PSA",
+    "description": "A brutal take on marriage from someone who learned the hard way. This caller is not holding back with the relationship advice tonight.",
+    "episode_number": 19,
+    "clip_file": "clip-2-don-t-get-married-psa.mp4",
+    "youtube_id": "6pKcYXgzizs",
+    "featured": false,
+    "thumbnail": "images/clips/clip-2-don-t-get-married-psa.jpg"
+  },
+  {
+    "title": "Signed Into an Illegal Poker Game",
+    "description": "Imagine walking into an illegal poker game and they make you sign a guest book with your real info. The audacity is actually impressive.",
+    "episode_number": 18,
+    "clip_file": "clip-2-signed-into-an-illegal-poker-game.mp4",
+    "youtube_id": "eCT0gUVLlbA",
+    "featured": false,
+    "thumbnail": "images/clips/clip-2-signed-into-an-illegal-poker-game.jpg"
+  },
+  {
+    "title": "We're Dinner for a Black Hole",
+    "description": "This caller has a theory that we're all just corn on the cob waiting to be eaten by a distant black hole. Can't stop thinking about it now.",
+    "episode_number": 17,
+    "clip_file": "clip-2-we-re-dinner-for-a-black-hole.mp4",
+    "youtube_id": "lakicW3cbPw",
+    "featured": false,
+    "thumbnail": "images/clips/clip-2-we-re-dinner-for-a-black-hole.jpg"
+  },
+  {
+    "title": "Maybe You Should Eat More of Her",
+    "description": "Luke doesn't hold back when a caller complains about his long-distance girlfriend not visiting enough. This relationship advice is absolutely WILD and you need to hear it.",
+    "episode_number": 16,
+    "clip_file": "clip-1-maybe-you-should-eat-more-of-her.mp4",
+    "youtube_id": "P5UNb_njsig",
+    "featured": false,
+    "thumbnail": "images/clips/clip-1-maybe-you-should-eat-more-of-her.jpg"
+  },
+  {
+    "title": "I Lied About Speaking Spanish for 8 Years",
+    "description": "This crop duster faked speaking Spanish to get hired and somehow kept the lie going for EIGHT YEARS. Now he's got a 3-week contract in Mexico City and he's about to get exposed.",
+    "episode_number": 14,
+    "clip_file": "clip-1-i-lied-about-speaking-spanish-for-8-years.mp4",
+    "youtube_id": "MxDjohJEneQ",
+    "featured": false,
+    "thumbnail": "images/clips/clip-1-i-lied-about-speaking-spanish-for-8-years.jpg"
+  },
+  {
+    "title": "You Can't Have It Both Ways",
+    "description": "This caller goes OFF on absent parents who use work as an excuse. Just because you're making money on the road doesn't mean you're present in your kid's life.",
+    "episode_number": 13,
+    "clip_file": "clip-2-you-can-t-have-it-both-ways.mp4",
+    "youtube_id": "Or62RF0uJQM",
+    "featured": false,
+    "thumbnail": "images/clips/clip-2-you-can-t-have-it-both-ways.jpg"
+  },
+  {
+    "title": "Pretending to Buy Houses for 8 Months",
+    "description": "For 8 months, this caller has been attending open houses every weekend pretending to be different people. They're not buying... they're just living fake lives for fun.",
+    "episode_number": 13,
+    "clip_file": "clip-3-pretending-to-buy-houses-for-8-months.mp4",
+    "youtube_id": "VSWknaHx7d0",
+    "featured": false,
+    "thumbnail": "images/clips/clip-3-pretending-to-buy-houses-for-8-months.jpg"
+  },
+  {
+    "title": "No More Thursdays in Deming",
+    "description": "Rita thought she was being sneaky meeting her ex every Thursday at a Deming motel... until her husband started tracking the mileage. Luke's response? Absolutely brutal.",
+    "episode_number": 11,
+    "clip_file": "clip-1-no-more-thursdays-in-deming.mp4",
+    "youtube_id": "weeDjSi7vuc",
+    "featured": false,
+    "thumbnail": "images/clips/clip-1-no-more-thursdays-in-deming.jpg"
+  },
+  {
+    "title": "Cemetery Widow Stalker",
+    "description": "A cemetery groundskeeper thought a widow was mourning her husband... until he realized she keeps showing up at midnight asking his COWORKERS about him. This one gets creepy fast.",
+    "episode_number": 8,
+    "clip_file": "clip-2-cemetery-widow-stalker.mp4",
+    "youtube_id": "dAiM1WT5-_A",
+    "featured": false,
+    "thumbnail": "images/clips/clip-2-cemetery-widow-stalker.jpg"
+  }
+]

website/episode.html

@@ -0,0 +1,127 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <meta name="theme-color" content="#1a1209">
+  <title id="page-title">Episode — Luke at the Roost</title>
+  <meta name="description" id="page-description" content="Full transcript of this episode of Luke at the Roost, the late-night call-in radio show.">
+  <link rel="canonical" id="page-canonical" href="https://lukeattheroost.com/episode.html">
+
+  <!-- OG / Social -->
+  <meta property="og:site_name" content="Luke at the Roost">
+  <meta property="og:title" id="og-title" content="Episode — Luke at the Roost">
+  <meta property="og:description" id="og-description" content="Full transcript of this episode of Luke at the Roost.">
+  <meta property="og:image" content="https://cdn.lukeattheroost.com/media/podcasts/LukeAtTheRoost/cover_feed.png?v=3">
+  <meta property="og:url" id="og-url" content="https://lukeattheroost.com/episode.html">
+  <meta property="og:type" content="article">
+  <meta name="twitter:card" content="summary_large_image">
+  <meta name="twitter:title" id="tw-title" content="Episode — Luke at the Roost">
+  <meta name="twitter:description" id="tw-description" content="Full transcript of this episode of Luke at the Roost.">
+  <meta name="twitter:image" content="https://cdn.lukeattheroost.com/media/podcasts/LukeAtTheRoost/cover_feed.png?v=3">
+
+  <!-- Favicon -->
+  <link rel="icon" href="favicon.ico" sizes="48x48">
+  <link rel="icon" type="image/svg+xml" href="favicon.svg">
+  <link rel="icon" type="image/png" sizes="192x192" href="favicon-192.png">
+  <link rel="icon" type="image/png" sizes="48x48" href="favicon-48.png">
+  <link rel="icon" type="image/png" sizes="32x32" href="favicon-32.png">
+  <link rel="icon" type="image/png" sizes="16x16" href="favicon-16.png">
+  <link rel="apple-touch-icon" href="apple-touch-icon.png">
+
+  <link rel="alternate" type="application/rss+xml" title="Luke at the Roost RSS Feed" href="https://podcast.macneilmediagroup.com/@LukeAtTheRoost/feed.xml">
+  <link rel="stylesheet" href="css/style.css?v=5">
+
+  <!-- Structured Data (dynamically updated by JS) -->
+  <script type="application/ld+json" id="episode-jsonld">
+  {
+    "@context": "https://schema.org",
+    "@type": "PodcastEpisode",
+    "partOfSeries": {
+      "@type": "PodcastSeries",
+      "name": "Luke at the Roost",
+      "url": "https://lukeattheroost.com"
+    },
+    "name": "Episode — Luke at the Roost",
+    "url": "https://lukeattheroost.com/episode.html",
+    "description": "Full transcript of this episode of Luke at the Roost.",
+    "inLanguage": "en"
+  }
+  </script>
+    <script defer data-domain="lukeattheroost.com" data-api="/p/event" src="/p/script"></script>
+    <script>window.plausible = window.plausible || function() { (window.plausible.q = window.plausible.q || []).push(arguments) }</script>
+</head>
+<body>
+
+  <a href="#main-content" class="skip-link">Skip to content</a>
+
+  <nav class="site-nav">
+    <a href="/" class="site-nav-brand">Luke at the Roost</a>
+    <div class="site-nav-links">
+      <a href="/how-it-works">How It Works</a>
+      <a href="/clips">Clips</a>
+      <a href="/stats">Stats</a>
+    </div>
+  </nav>
+
+  <main id="main-content">
+
+  <!-- Episode Header -->
+  <section class="ep-header" id="ep-header">
+    <div class="ep-header-inner">
+      <div class="ep-meta" id="ep-meta"></div>
+      <h1 class="ep-title" id="ep-title">Loading...</h1>
+      <p class="ep-desc" id="ep-desc"></p>
+      <div class="ep-actions">
+        <button class="ep-play-btn" id="ep-play-btn" style="display:none" aria-label="Play Episode">
+          <svg viewBox="0 0 24 24" fill="currentColor"><path d="M8 5v14l11-7z"/></svg>
+          <span>Play Episode</span>
+        </button>
+      </div>
+    </div>
+  </section>
+
+  <!-- Transcript -->
+  <section class="transcript-section" id="transcript-section">
+    <h2>Full Transcript</h2>
+    <div class="transcript-body" id="transcript-body">
+      <div class="episodes-loading">Loading transcript...</div>
+    </div>
+  </section>
+
+  </main>
+
+  <noscript>
+    <section class="transcript-section">
+      <p>This page requires JavaScript to load the episode transcript. Please enable JavaScript or listen on <a href="https://open.spotify.com/show/0ZrpMigG1fo0CCN7F4YmuF">Spotify</a>, <a href="https://podcasts.apple.com/us/podcast/luke-at-the-roost/id1875205848">Apple Podcasts</a>, or <a href="https://www.youtube.com/watch?v=xryGLifMBTY&list=PLGq4uZyNV1yYH_rcitTTPVysPbC6-7pe-">YouTube</a>.</p>
+    </section>
+  </noscript>
+
+  <footer class="footer"></footer>
+
+  <!-- Sticky Audio Player -->
+  <div class="sticky-player" id="sticky-player">
+    <div class="player-inner">
+      <button class="player-play-btn" id="player-play-btn" aria-label="Play/Pause">
+        <svg class="icon-play" viewBox="0 0 24 24"><path d="M8 5v14l11-7z"/></svg>
+        <svg class="icon-pause" viewBox="0 0 24 24" style="display:none"><path d="M6 19h4V5H6v14zm8-14v14h4V5h-4z"/></svg>
+      </button>
+      <div class="player-info">
+        <div class="player-title" id="player-title">—</div>
+        <div class="player-progress-row">
+          <div class="player-progress" id="player-progress" role="slider" aria-label="Audio progress" aria-valuemin="0" aria-valuemax="100" aria-valuenow="0" tabindex="0">
+            <div class="player-progress-fill" id="player-progress-fill"></div>
+          </div>
+          <span class="player-time" id="player-time">0:00 / 0:00</span>
+        </div>
+      </div>
+    </div>
+  </div>
+
+  <audio id="audio-element" preload="none"></audio>
+
+  <script src="js/footer.js"></script>
+  <script src="js/player.js"></script>
+  <script src="js/episode.js"></script>
+</body>
+</html>

website/favicon.svg

@@ -0,0 +1,35 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64">
+  <defs>
+    <filter id="glow">
+      <feGaussianBlur stdDeviation="2" result="blur"/>
+      <feMerge>
+        <feMergeNode in="blur"/>
+        <feMergeNode in="SourceGraphic"/>
+      </feMerge>
+    </filter>
+  </defs>
+  <!-- Dark background circle -->
+  <circle cx="32" cy="32" r="30" fill="#1a1209"/>
+  <!-- Neon rooster silhouette -->
+  <g filter="url(#glow)" fill="none" stroke="#e8791d" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round">
+    <!-- Comb -->
+    <path d="M30 12c1-3 3-5 5-5s3 2 3 4c0-2 2-3 3-2s1 3 0 5"/>
+    <!-- Head -->
+    <path d="M30 12c-2 1-4 4-4 7 0 3 2 6 6 7"/>
+    <path d="M41 19c0-3-2-6-5-7"/>
+    <!-- Eye -->
+    <circle cx="33" cy="16" r="1.5" fill="#e8791d"/>
+    <!-- Beak -->
+    <path d="M26 17l-3 1 3 2"/>
+    <!-- Body -->
+    <path d="M32 26c-5 1-9 5-10 10l-1 6c0 1 1 2 2 2h3"/>
+    <path d="M32 26c5 1 9 5 10 10l1 6c0 1-1 2-2 2h-3"/>
+    <!-- Tail feathers -->
+    <path d="M42 30c3-4 6-8 7-14"/>
+    <path d="M43 32c4-3 8-5 10-10"/>
+    <path d="M44 35c4-1 7-2 9-5"/>
+    <!-- Legs -->
+    <path d="M27 44l-2 8M25 52l-3 1M25 52l2 1"/>
+    <path d="M37 44l2 8M39 52l-2 1M39 52l3 1"/>
+  </g>
+</svg>

website/how-it-works.html

@@ -0,0 +1,676 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>How It Works — Luke at the Roost</title>
+  <meta name="description" content="How Luke at the Roost works: AI-generated callers with structured personalities, comedy-tuned call shapes, a live research intern, voice-personality matching, multi-stem recording, and automated post-production.">
+  <meta name="theme-color" content="#1a1209">
+  <link rel="canonical" href="https://lukeattheroost.com/how-it-works">
+
+  <meta property="og:site_name" content="Luke at the Roost">
+  <meta property="og:title" content="How It Works — Luke at the Roost">
+  <meta property="og:description" content="The tech behind a one-of-a-kind AI radio show: real-time caller generation, multi-stem recording, automated post-production, and global CDN distribution — all custom-built.">
+  <meta property="og:image" content="https://cdn.lukeattheroost.com/media/podcasts/LukeAtTheRoost/cover_feed.png?v=3">
+  <meta property="og:url" content="https://lukeattheroost.com/how-it-works">
+  <meta property="og:type" content="website">
+  <meta name="twitter:card" content="summary_large_image">
+  <meta name="twitter:title" content="How It Works — Luke at the Roost">
+  <meta name="twitter:description" content="The tech behind a one-of-a-kind AI radio show: real-time caller generation, multi-stem recording, automated post-production, and global CDN distribution.">
+  <meta name="twitter:image" content="https://cdn.lukeattheroost.com/media/podcasts/LukeAtTheRoost/cover_feed.png?v=3">
+
+  <link rel="icon" href="favicon.ico" sizes="48x48">
+  <link rel="icon" type="image/svg+xml" href="favicon.svg">
+  <link rel="icon" type="image/png" sizes="192x192" href="favicon-192.png">
+  <link rel="icon" type="image/png" sizes="48x48" href="favicon-48.png">
+  <link rel="icon" type="image/png" sizes="32x32" href="favicon-32.png">
+  <link rel="icon" type="image/png" sizes="16x16" href="favicon-16.png">
+  <link rel="apple-touch-icon" href="apple-touch-icon.png">
+
+  <link rel="alternate" type="application/rss+xml" title="Luke at the Roost RSS Feed" href="https://podcast.macneilmediagroup.com/@LukeAtTheRoost/feed.xml">
+  <link rel="stylesheet" href="css/style.css?v=5">
+
+  <!-- Structured Data -->
+  <script type="application/ld+json">
+  [{
+    "@context": "https://schema.org",
+    "@type": "TechArticle",
+    "headline": "How Luke at the Roost Works",
+    "description": "How Luke at the Roost works: AI-generated callers with unique personalities, real phone calls, voice synthesis, multi-stem recording, and automated post-production.",
+    "url": "https://lukeattheroost.com/how-it-works",
+    "image": "https://cdn.lukeattheroost.com/media/podcasts/LukeAtTheRoost/cover_feed.png?v=3",
+    "author": {
+      "@type": "Person",
+      "name": "Luke MacNeil"
+    },
+    "publisher": {
+      "@type": "Organization",
+      "name": "MacNeil Media Group"
+    },
+    "about": {
+      "@type": "PodcastSeries",
+      "name": "Luke at the Roost",
+      "url": "https://lukeattheroost.com"
+    },
+    "inLanguage": "en"
+  },
+  {
+    "@context": "https://schema.org",
+    "@type": "BreadcrumbList",
+    "itemListElement": [
+      { "@type": "ListItem", "position": 1, "name": "Home", "item": "https://lukeattheroost.com" },
+      { "@type": "ListItem", "position": 2, "name": "How It Works" }
+    ]
+  }]
+  </script>
+    <script defer data-domain="lukeattheroost.com" data-api="/p/event" src="/p/script"></script>
+    <script>window.plausible = window.plausible || function() { (window.plausible.q = window.plausible.q || []).push(arguments) }</script>
+</head>
+<body>
+
+  <a href="#main-content" class="skip-link">Skip to content</a>
+
+  <nav class="site-nav">
+    <a href="/" class="site-nav-brand">Luke at the Roost</a>
+    <div class="site-nav-links">
+      <a href="/how-it-works" aria-current="page">How It Works</a>
+      <a href="/clips">Clips</a>
+      <a href="/stats">Stats</a>
+    </div>
+  </nav>
+
+  <main id="main-content">
+
+  <!-- Page Header -->
+  <section class="page-header">
+    <h1>How It Works</h1>
+    <p class="page-subtitle">Every caller on the show is a one-of-a-kind character — generated in real time by a custom-built AI system. Here's a peek behind the curtain.</p>
+  </section>
+
+  <!-- Steps -->
+  <section class="hiw-section">
+    <h2>The Anatomy of an AI Caller</h2>
+
+    <div class="hiw-steps">
+      <div class="hiw-step">
+        <div class="hiw-step-number">1</div>
+        <div class="hiw-step-content">
+          <h3>A Person Is Born</h3>
+          <p>Every caller starts as a blank slate. The system generates a complete identity: name, age, job, hometown, and personality. Each caller gets a unique speaking style — some ramble, some are blunt, some deflect with humor. They have relationships, vehicles, strong food opinions, nostalgic memories, and reasons for being up this late. They know what they were watching on TV, what errand they ran today, and what song was on the radio before they called.</p>
+          <p>But it goes deeper than backstory. Every caller is built with a structured call shape — maybe an escalating reveal where they start casual and drop a bombshell halfway through, a bait-and-switch where the real issue isn't what they said at first, or a slow burn that builds to an emotional peak. They have energy levels, emotional states, and signature details — a phrase they keep coming back to, a nervous tic in how they talk, a specific detail that makes the whole thing feel real. And each caller is matched to a voice that fits their personality. A 60-year-old trucker from Lordsburg doesn't sound like a 23-year-old barista from Tucson.</p>
+          <p>Some callers become regulars. The system tracks returning callers across episodes — they remember past conversations, reference things they talked about before, and their stories evolve over time. You'll hear Leon check in about going back to school, or Shaniqua update you on her situation at work. They're not reset between shows.</p>
+          <p>And some callers are drunk, high, or flat-out unhinged. They'll call with conspiracy theories about pigeons being government drones, existential crises about whether fish know they're wet, or to confess they accidentally set their kitchen on fire trying to make grilled cheese at 3 AM.</p>
+          <div class="hiw-detail-grid">
+            <div class="hiw-detail">
+              <span class="hiw-detail-label">Unique Names</span>
+              <span class="hiw-detail-value">160</span>
+            </div>
+            <div class="hiw-detail">
+              <span class="hiw-detail-label">Voice Profiles</span>
+              <span class="hiw-detail-value">68</span>
+            </div>
+            <div class="hiw-detail">
+              <span class="hiw-detail-label">Call Shapes</span>
+              <span class="hiw-detail-value">8 types</span>
+            </div>
+            <div class="hiw-detail">
+              <span class="hiw-detail-label">Returning Regulars</span>
+              <span class="hiw-detail-value">12 callers</span>
+            </div>
+          </div>
+        </div>
+      </div>
+
+      <div class="hiw-step">
+        <div class="hiw-step-number">2</div>
+        <div class="hiw-step-content">
+          <h3>They Know Their World</h3>
+          <p>Callers know real facts about where they live — the restaurants, the highways, the local gossip. The system has deep knowledge of 55 real towns across New Mexico and Arizona. When a caller says they're from Lordsburg, they actually know about the Shakespeare ghost town and the drive to Deming. They know the current weather outside their window, what day of the week it is, whether it's monsoon season or chile harvest. They have strong opinions about where to get the best green chile and get nostalgic about how their town used to be. The system also pulls in real-time news so callers can reference things that actually happened today.</p>
+        </div>
+      </div>
+
+      <div class="hiw-step">
+        <div class="hiw-step-number">3</div>
+        <div class="hiw-step-content">
+          <h3>They Have a Reason to Call</h3>
+          <p>Some callers have a problem — a fight with a neighbor, a situation at work, something weighing on them at 2 AM. Others call to geek out about Severance, argue about poker strategy, or share something they read about quantum physics. The system draws from over 1,000 unique calling reasons across dozens of categories — problems, stories, advice-seeking, gossip, and deep-dive topics. Every caller has a purpose, not just a script.</p>
+          <p>The whole thing is tuned for comedy. Not "AI tries to be funny" comedy — more like the energy of late-night call-in radio meets stand-up meets the kind of confessions you only hear at 2 AM. Some calls are genuinely heartfelt. Some are absurd. Some start serious and go completely sideways. The system knows how to build a call for comedic timing — when to hold back a detail, when to escalate, when to let the awkward silence do the work. It's not random chaos; it's structured chaos.</p>
+          <div class="hiw-split-stat">
+            <div class="hiw-stat">
+              <span class="hiw-stat-number">70%</span>
+              <span class="hiw-stat-label">Need advice</span>
+            </div>
+            <div class="hiw-stat">
+              <span class="hiw-stat-number">30%</span>
+              <span class="hiw-stat-label">Want to talk about something</span>
+            </div>
+          </div>
+        </div>
+      </div>
+
+      <div class="hiw-step">
+        <div class="hiw-step-number">4</div>
+        <div class="hiw-step-content">
+          <h3>The Conversation Is Real</h3>
+          <p>Luke talks to each caller using push-to-talk, just like a real radio show. His voice is transcribed in real time, sent to an AI that responds in character, and then converted to speech using a voice engine — all in a few seconds. The AI doesn't just answer questions; it reacts, gets emotional, goes on tangents, and remembers what was said earlier in the show.</p>
+          <p>Callers don't just exist in isolation — the show tracks what's been discussed and matches callers thematically. If someone just called about a messy divorce, the next caller who references marriage didn't pick that topic randomly. The system scores previous callers by topic overlap and decides whether the new caller should reference them, disagree with them, or build on what they said. It tracks the show's overall energy so the pacing doesn't flatline — a heavy emotional call might be followed by something lighter, and vice versa.</p>
+          <p>And when a call has run its course, Luke can hit "Wrap It Up" — a signal that tells the caller to wind things down gracefully. Instead of an abrupt hang-up, the caller gets the hint and starts wrapping up their thought, says their goodbyes, and exits naturally. Just like a real radio host giving the "time's up" hand signal through the glass.</p>
+        </div>
+      </div>
+
+      <div class="hiw-step">
+        <div class="hiw-step-number">5</div>
+        <div class="hiw-step-content">
+          <h3>Real Callers Call In Too</h3>
+          <p>When you dial 208-439-LUKE, your call goes into a live queue. Luke sees you waiting and can take your call right from the control room. Your voice streams in real time — no pre-recording, no delay. You're live on the show, talking to Luke, and the AI callers might even react to what you said. And if Luke isn't live, you can leave a voicemail — it gets transcribed and may get played on a future episode.</p>
+        </div>
+      </div>
+
+      <div class="hiw-step">
+        <div class="hiw-step-number">6</div>
+        <div class="hiw-step-content">
+          <h3>Listener Emails</h3>
+          <p>Listeners can send emails to <a href="mailto:submissions@lukeattheroost.com" style="color:var(--accent)">submissions@lukeattheroost.com</a> and have them read on the show. A background poller checks for new messages every 30 seconds — they show up in the control room as soon as they arrive. Luke can read them himself on the mic, or hit a button to have an AI voice read them aloud on the caller channel. It's like a call-in show meets a letters segment — listeners who can't call in can still be part of the conversation.</p>
+        </div>
+      </div>
+
+      <div class="hiw-step">
+        <div class="hiw-step-number">7</div>
+        <div class="hiw-step-content">
+          <h3>Devon the Intern</h3>
+          <p>Every show needs someone to yell at. Devon is the show's intern — a 23-year-old NMSU grad who's way too eager, occasionally useful, and frequently wrong. He's not a caller; he's a permanent fixture of the show. When Luke needs a fact checked, a topic researched, or someone to blame for a technical issue, Devon's there.</p>
+          <p>Devon has real tools. He can search the web, pull up news headlines, look things up on Wikipedia, and read articles — all live during the show. When a caller claims that octopuses have three hearts, Devon's already looking it up. Sometimes he interjects on his own when he thinks he has something useful to add. Sometimes he's right. Sometimes Luke tells him to shut up. He monitors conversations in the background and pipes up with suggestions that the host can play or dismiss. He's the kind of intern who tries really hard and occasionally nails it.</p>
+        </div>
+      </div>
+
+      <div class="hiw-step">
+        <div class="hiw-step-number">8</div>
+        <div class="hiw-step-content">
+          <h3>The Control Room</h3>
+          <p>The entire show runs through a custom-built control panel. Luke manages callers, plays music and sound effects, runs ads and station idents, monitors the call queue, and controls everything from one screen. Audio is routed across seven independent channels simultaneously — host mic, AI caller voices, live phone audio, music, sound effects, ads, and station idents all on separate tracks. The website shows a live on-air indicator so listeners know when to call in.</p>
+          <div class="hiw-detail-grid">
+            <div class="hiw-detail">
+              <span class="hiw-detail-label">Audio Channels</span>
+              <span class="hiw-detail-value">7 independent</span>
+            </div>
+            <div class="hiw-detail">
+              <span class="hiw-detail-label">Caller Slots</span>
+              <span class="hiw-detail-value">10 per session</span>
+            </div>
+            <div class="hiw-detail">
+              <span class="hiw-detail-label">Phone System</span>
+              <span class="hiw-detail-value">VoIP + WebSocket</span>
+            </div>
+            <div class="hiw-detail">
+              <span class="hiw-detail-label">Live Status</span>
+              <span class="hiw-detail-value">Real-time CDN</span>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+  </section>
+
+  <!-- Overview -->
+  <section class="hiw-section">
+    <div class="hiw-card hiw-hero-card">
+      <div class="hiw-diagram">
+        <!-- Row 1: Inputs -->
+        <div class="diagram-label">Live Show</div>
+        <div class="diagram-row diagram-row-split">
+          <div class="diagram-box diagram-accent">
+            <div class="diagram-icon">
+              <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M12 1a3 3 0 0 0-3 3v8a3 3 0 0 0 6 0V4a3 3 0 0 0-3-3z"/><path d="M19 10v2a7 7 0 0 1-14 0v-2"/><line x1="12" y1="19" x2="12" y2="23"/><line x1="8" y1="23" x2="16" y2="23"/></svg>
+            </div>
+            <span>Luke (Host)</span>
+          </div>
+          <div class="diagram-box diagram-accent">
+            <div class="diagram-icon">
+              <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M17 21v-2a4 4 0 0 0-4-4H5a4 4 0 0 0-4 4v2"/><circle cx="9" cy="7" r="4"/><path d="M23 21v-2a4 4 0 0 0-3-3.87"/><path d="M16 3.13a4 4 0 0 1 0 7.75"/></svg>
+            </div>
+            <span>AI Callers</span>
+          </div>
+          <div class="diagram-box diagram-accent">
+            <div class="diagram-icon">
+              <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M22 16.92v3a2 2 0 0 1-2.18 2 19.79 19.79 0 0 1-8.63-3.07 19.5 19.5 0 0 1-6-6 19.79 19.79 0 0 1-3.07-8.67A2 2 0 0 1 4.11 2h3a2 2 0 0 1 2 1.72 12.84 12.84 0 0 0 .7 2.81 2 2 0 0 1-.45 2.11L8.09 9.91a16 16 0 0 0 6 6l1.27-1.27a2 2 0 0 1 2.11-.45 12.84 12.84 0 0 0 2.81.7A2 2 0 0 1 22 16.92z"/></svg>
+            </div>
+            <span>Real Callers</span>
+          </div>
+          <div class="diagram-box diagram-accent">
+            <div class="diagram-icon">
+              <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><rect x="2" y="2" width="20" height="16" rx="2"/><path d="M2 6l10 7 10-7"/></svg>
+            </div>
+            <span>Voicemails</span>
+          </div>
+          <div class="diagram-box diagram-accent">
+            <div class="diagram-icon">
+              <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M4 4h16c1.1 0 2 .9 2 2v12c0 1.1-.9 2-2 2H4c-1.1 0-2-.9-2-2V6c0-1.1.9-2 2-2z"/><polyline points="22,6 12,13 2,6"/></svg>
+            </div>
+            <span>Listener Emails</span>
+          </div>
+        </div>
+        <div class="diagram-arrow">&#8595;</div>
+        <!-- Row 2: Control Room -->
+        <div class="diagram-row">
+          <div class="diagram-box">
+            <div class="diagram-icon">
+              <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><rect x="2" y="3" width="20" height="14" rx="2"/><line x1="8" y1="21" x2="16" y2="21"/><line x1="12" y1="17" x2="12" y2="21"/></svg>
+            </div>
+            <span>Control Room</span>
+          </div>
+        </div>
+        <div class="diagram-arrow">&#8595;</div>
+        <!-- Row 3: Engine Layer -->
+        <div class="diagram-row diagram-row-split">
+          <div class="diagram-box">
+            <div class="diagram-icon">
+              <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z"/></svg>
+            </div>
+            <span>LLM Dialog</span>
+          </div>
+          <div class="diagram-box">
+            <div class="diagram-icon">
+              <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M12 1a3 3 0 0 0-3 3v8a3 3 0 0 0 6 0V4a3 3 0 0 0-3-3z"/><path d="M19 10v2a7 7 0 0 1-14 0v-2"/></svg>
+            </div>
+            <span>Voice Synthesis</span>
+          </div>
+          <div class="diagram-box">
+            <div class="diagram-icon">
+              <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="12" cy="12" r="10"/><line x1="2" y1="12" x2="22" y2="12"/><path d="M12 2a15.3 15.3 0 0 1 4 10 15.3 15.3 0 0 1-4 10 15.3 15.3 0 0 1-4-10 15.3 15.3 0 0 1 4-10z"/></svg>
+            </div>
+            <span>Live Data</span>
+          </div>
+          <div class="diagram-box">
+            <div class="diagram-icon">
+              <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M9 18V5l12-2v13"/><circle cx="6" cy="18" r="3"/><circle cx="18" cy="16" r="3"/></svg>
+            </div>
+            <span>Audio Router</span>
+          </div>
+          <div class="diagram-box">
+            <div class="diagram-icon">
+              <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M22 16.92v3a2 2 0 0 1-2.18 2 19.79 19.79 0 0 1-8.63-3.07 19.5 19.5 0 0 1-6-6 19.79 19.79 0 0 1-3.07-8.67A2 2 0 0 1 4.11 2h3a2 2 0 0 1 2 1.72 12.84 12.84 0 0 0 .7 2.81 2 2 0 0 1-.45 2.11L8.09 9.91a16 16 0 0 0 6 6l1.27-1.27a2 2 0 0 1 2.11-.45 12.84 12.84 0 0 0 2.81.7A2 2 0 0 1 22 16.92z"/></svg>
+            </div>
+            <span>Phone System</span>
+          </div>
+          <div class="diagram-box">
+            <div class="diagram-icon">
+              <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><rect x="3" y="3" width="18" height="18" rx="2"/><path d="M3 9h18"/><path d="M9 21V9"/></svg>
+            </div>
+            <span>Ad Engine</span>
+          </div>
+        </div>
+        <!-- Row 4: Recording -->
+        <div class="diagram-row">
+          <div class="diagram-box">
+            <div class="diagram-icon">
+              <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="12" cy="12" r="10"/><circle cx="12" cy="12" r="3" fill="currentColor"/></svg>
+            </div>
+            <span>Multi-Stem Recorder</span>
+          </div>
+        </div>
+        <div class="diagram-arrow">&#8595;</div>
+        <!-- Row 5: Post-Production -->
+        <div class="diagram-label">Post-Production</div>
+        <div class="diagram-row diagram-row-split">
+          <div class="diagram-box">
+            <div class="diagram-icon">
+              <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><polygon points="11 5 6 9 2 9 2 15 6 15 11 19 11 5"/><path d="M19.07 4.93a10 10 0 0 1 0 14.14"/><path d="M15.54 8.46a5 5 0 0 1 0 7.07"/></svg>
+            </div>
+            <span>Compression &amp; Ducking</span>
+          </div>
+          <div class="diagram-box">
+            <div class="diagram-icon">
+              <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><polyline points="22 12 18 12 15 21 9 3 6 12 2 12"/></svg>
+            </div>
+            <span>Loudness Normalization</span>
+          </div>
+          <div class="diagram-box">
+            <div class="diagram-icon">
+              <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z"/><polyline points="14 2 14 8 20 8"/><line x1="16" y1="13" x2="8" y2="13"/><line x1="16" y1="17" x2="8" y2="17"/></svg>
+            </div>
+            <span>Transcription</span>
+          </div>
+        </div>
+        <div class="diagram-arrow">&#8595;</div>
+        <!-- Row 6: Publishing -->
+        <div class="diagram-label">Publishing</div>
+        <div class="diagram-row diagram-row-split">
+          <div class="diagram-box">
+            <div class="diagram-icon">
+              <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M4 15s1-1 4-1 5 2 8 2 4-1 4-1V3s-1 1-4 1-5-2-8-2-4 1-4 1z"/><line x1="4" y1="22" x2="4" y2="15"/></svg>
+            </div>
+            <span>Podcast Server</span>
+          </div>
+          <div class="diagram-box">
+            <div class="diagram-icon">
+              <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M22 12h-4l-3 9L9 3l-3 9H2"/></svg>
+            </div>
+            <span>CDN Edge Network</span>
+          </div>
+          <div class="diagram-box">
+            <div class="diagram-icon">
+              <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><rect x="2" y="3" width="20" height="14" rx="2"/><line x1="8" y1="21" x2="16" y2="21"/><line x1="12" y1="17" x2="12" y2="21"/></svg>
+            </div>
+            <span>Website</span>
+          </div>
+          <div class="diagram-box">
+            <div class="diagram-icon">
+              <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><rect x="2" y="3" width="20" height="11" rx="2"/><path d="M7 21h10"/><path d="M12 14v7"/><polygon points="10 8 16 11 10 14 10 8"/></svg>
+            </div>
+            <span>Social Clips</span>
+          </div>
+          <div class="diagram-box">
+            <div class="diagram-icon">
+              <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M22 12h-4l-3 9L9 3l-3 9H2"/></svg>
+            </div>
+            <span>Monitoring</span>
+          </div>
+        </div>
+        <div class="diagram-arrow">&#8595;</div>
+        <!-- Row 7: Distribution -->
+        <div class="diagram-label">Distribution</div>
+        <div class="diagram-row-compact">
+          <div class="diagram-box diagram-accent">
+            <div class="diagram-icon">
+              <svg viewBox="0 0 24 24" fill="currentColor"><path d="M12 0C5.4 0 0 5.4 0 12s5.4 12 12 12 12-5.4 12-12S18.66 0 12 0zm5.521 17.34c-.24.359-.66.48-1.021.24-2.82-1.74-6.36-2.101-10.561-1.141-.418.122-.779-.179-.899-.539-.12-.421.18-.78.54-.9 4.56-1.021 8.52-.6 11.64 1.32.42.18.479.659.301 1.02zm1.44-3.3c-.301.42-.841.6-1.262.3-3.239-1.98-8.159-2.58-11.939-1.38-.479.12-1.02-.12-1.14-.6-.12-.48.12-1.021.6-1.141C9.6 9.9 15 10.561 18.72 12.84c.361.181.54.78.241 1.2zm.12-3.36C15.24 8.4 8.82 8.16 5.16 9.301c-.6.179-1.2-.181-1.38-.721-.18-.601.18-1.2.72-1.381 4.26-1.26 11.28-1.02 15.721 1.621.539.3.719 1.02.419 1.56-.299.421-1.02.599-1.559.3z"/></svg>
+            </div>
+            <span>Spotify</span>
+          </div>
+          <div class="diagram-box diagram-accent">
+            <div class="diagram-icon">
+              <svg viewBox="0 0 24 24" fill="currentColor"><path d="M5.34 0A5.328 5.328 0 0 0 0 5.34v13.32A5.328 5.328 0 0 0 5.34 24h13.32A5.328 5.328 0 0 0 24 18.66V5.34A5.328 5.328 0 0 0 18.66 0z"/></svg>
+            </div>
+            <span>Apple</span>
+          </div>
+          <div class="diagram-box diagram-accent">
+            <div class="diagram-icon">
+              <svg viewBox="0 0 24 24" fill="currentColor"><path d="M23.498 6.186a3.016 3.016 0 0 0-2.122-2.136C19.505 3.545 12 3.545 12 3.545s-7.505 0-9.377.505A3.017 3.017 0 0 0 .502 6.186C0 8.07 0 12 0 12s0 3.93.502 5.814a3.016 3.016 0 0 0 2.122 2.136c1.871.505 9.376.505 9.376.505s7.505 0 9.377-.505a3.015 3.015 0 0 0 2.122-2.136C24 15.93 24 12 24 12s0-3.93-.502-5.814z"/><path d="M9.545 15.568V8.432L15.818 12z" fill="#fff"/></svg>
+            </div>
+            <span>YouTube</span>
+          </div>
+          <div class="diagram-box diagram-accent">
+            <div class="diagram-icon">
+              <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M6.503 20.752c0 1.794-1.456 3.248-3.251 3.248S0 22.546 0 20.752s1.456-3.248 3.252-3.248 3.251 1.454 3.251 3.248z"/><path d="M.002 9.473v4.594c5.508.163 9.929 4.584 10.092 10.091h4.594"/><path d="M.006 0v4.604C10.81 4.77 19.23 13.19 19.396 24h4.604"/></svg>
+            </div>
+            <span>RSS</span>
+          </div>
+          <div class="diagram-box diagram-accent">
+            <div class="diagram-icon">
+              <svg viewBox="0 0 24 24" fill="currentColor"><path d="M12 2C6.5 2 2 6.5 2 12s4.5 10 10 10 10-4.5 10-10S17.5 2 12 2zm3.1 14.5c-1.7 1-3.8.6-4.8-1.1-1-1.7-.6-3.8 1.1-4.8 1.7-1 3.8-.6 4.8 1.1 1 1.7.5 3.8-1.1 4.8z"/></svg>
+            </div>
+            <span>Instagram</span>
+          </div>
+          <div class="diagram-box diagram-accent">
+            <div class="diagram-icon">
+              <svg viewBox="0 0 24 24" fill="currentColor"><path d="M24 12.073c0-6.627-5.373-12-12-12s-12 5.373-12 12c0 5.99 4.388 10.954 10.125 11.854v-8.385H7.078v-3.47h3.047V9.43c0-3.007 1.792-4.669 4.533-4.669 1.312 0 2.686.235 2.686.235v2.953H15.83c-1.491 0-1.956.925-1.956 1.874v2.25h3.328l-.532 3.47h-2.796v8.385C19.612 23.027 24 18.062 24 12.073z"/></svg>
+            </div>
+            <span>Facebook</span>
+          </div>
+          <div class="diagram-box diagram-accent">
+            <div class="diagram-icon">
+              <svg viewBox="0 0 568 501" fill="currentColor"><path d="M123.121 33.664C188.241 82.553 258.281 181.68 284 234.873c25.719-53.192 95.759-152.32 160.879-201.21C491.866-1.611 568-28.906 568 57.947c0 17.346-9.945 145.713-15.778 166.555-20.275 72.453-94.155 90.933-159.875 79.748C507.222 323.8 536.444 388.56 473.333 453.32c-119.86 122.992-172.272-30.859-185.702-70.281-2.462-7.227-3.614-10.608-3.631-7.733-.017-2.875-1.169.506-3.631 7.733-13.43 39.422-65.842 193.273-185.702 70.281-63.111-64.76-33.89-129.52 80.986-149.071-65.72 11.185-139.6-7.295-159.875-79.748C10.945 203.659 1 75.291 1 57.946 1-28.906 76.134-1.612 123.121 33.664z"/></svg>
+            </div>
+            <span>Bluesky</span>
+          </div>
+          <div class="diagram-box diagram-accent">
+            <div class="diagram-icon">
+              <svg viewBox="0 0 24 24" fill="currentColor"><path d="M23.268 5.313c-.35-2.578-2.617-4.61-5.304-5.004C17.51.242 15.792 0 11.813 0h-.03c-3.98 0-4.835.242-5.288.309C3.882.692 1.496 2.518.917 5.127.64 6.412.61 7.837.661 9.143c.074 1.874.088 3.745.26 5.611.118 1.24.325 2.47.62 3.68.55 2.237 2.777 4.098 4.96 4.857 2.336.792 4.849.923 7.256.38.265-.061.527-.132.786-.213.585-.184 1.27-.39 1.774-.753a.057.057 0 0 0 .023-.043v-1.809a.052.052 0 0 0-.02-.041.053.053 0 0 0-.046-.01 20.282 20.282 0 0 1-4.709.545c-2.73 0-3.463-1.284-3.674-1.818a5.593 5.593 0 0 1-.319-1.433.053.053 0 0 1 .066-.054 19.648 19.648 0 0 0 4.636.528c.164 0 .329 0 .494-.002 1.694-.042 3.48-.152 5.12-.554 2.21-.543 4.137-2.186 4.348-4.55.162-1.808.21-3.627.142-5.43-.02-.6-.168-1.874-.168-1.874z"/><path d="M19.903 7.515v5.834c0 1.226-.996 2.222-2.222 2.222h-.796c-1.226 0-2.222-.996-2.222-2.222V7.628c0-1.226.996-2.222 2.222-2.222h.796c.122 0 .242.01.36.03 1.076.164 1.862 1.098 1.862 2.192zM9.337 7.515v5.834c0 1.226-.996 2.222-2.222 2.222h-.796c-1.226 0-2.222-.996-2.222-2.222V7.628c0-1.226.996-2.222 2.222-2.222h.796c.122 0 .242.01.36.03 1.076.164 1.862 1.098 1.862 2.192z" fill="#fff"/></svg>
+            </div>
+            <span>Mastodon</span>
+          </div>
+          <div class="diagram-box diagram-accent">
+            <div class="diagram-icon">
+              <svg viewBox="0 0 24 24" fill="currentColor"><path d="M12.186.31a.27.27 0 0 0-.372 0C8.46 3.487 2.666 9.93 2.666 15.042c0 5.176 4.183 8.958 9.334 8.958s9.334-3.782 9.334-8.958c0-5.112-5.794-11.555-9.148-14.732z"/></svg>
+            </div>
+            <span>Nostr</span>
+          </div>
+          <div class="diagram-box diagram-accent">
+            <div class="diagram-icon">
+              <svg viewBox="0 0 24 24" fill="currentColor"><path d="M20.447 20.452h-3.554v-5.569c0-1.328-.027-3.037-1.852-3.037-1.853 0-2.136 1.445-2.136 2.939v5.667H9.351V9h3.414v1.561h.046c.477-.9 1.637-1.85 3.37-1.85 3.601 0 4.267 2.37 4.267 5.455v6.286zM5.337 7.433a2.062 2.062 0 0 1-2.063-2.065 2.064 2.064 0 1 1 2.063 2.065zm1.782 13.019H3.555V9h3.564v11.452zM22.225 0H1.771C.792 0 0 .774 0 1.729v20.542C0 23.227.792 24 1.771 24h20.451C23.2 24 24 23.227 24 22.271V1.729C24 .774 23.2 0 22.222 0h.003z"/></svg>
+            </div>
+            <span>LinkedIn</span>
+          </div>
+          <div class="diagram-box diagram-accent">
+            <div class="diagram-icon">
+              <svg viewBox="0 0 24 24" fill="currentColor"><path d="M12.159 2c-5.543 0-9.94 4.486-9.94 9.94 0 2.16.72 4.148 1.897 5.852l-1.26 4.463 4.612-1.188A9.882 9.882 0 0 0 12.16 22c5.543 0 9.94-4.486 9.94-9.94 0-5.543-4.486-10.06-9.94-10.06z"/></svg>
+            </div>
+            <span>Threads</span>
+          </div>
+          <div class="diagram-box diagram-accent">
+            <div class="diagram-icon">
+              <svg viewBox="0 0 24 24" fill="currentColor"><path d="M12.525.02c1.31-.02 2.61-.01 3.91-.02.08 1.53.63 3.09 1.75 4.17 1.12 1.11 2.7 1.62 4.24 1.79v4.03c-1.44-.05-2.89-.35-4.2-.97-.57-.26-1.1-.59-1.62-.93-.01 2.92.01 5.84-.02 8.75-.08 1.4-.54 2.79-1.35 3.94-1.31 1.92-3.58 3.17-5.91 3.21-1.43.08-2.86-.31-4.08-1.03-2.02-1.19-3.44-3.37-3.65-5.71-.02-.5-.03-1-.01-1.49.18-1.9 1.12-3.72 2.58-4.96 1.66-1.44 3.98-2.13 6.15-1.72.02 1.48-.04 2.96-.04 4.44-.99-.32-2.15-.23-3.02.37-.63.41-1.11 1.04-1.36 1.75-.21.51-.15 1.07-.14 1.61.24 1.64 1.82 3.02 3.5 2.87 1.12-.01 2.19-.66 2.77-1.61.19-.33.4-.67.41-1.06.1-1.79.06-3.57.07-5.36.01-4.03-.01-8.05.02-12.07z"/></svg>
+            </div>
+            <span>TikTok</span>
+          </div>
+          <div class="diagram-box diagram-accent">
+            <div class="diagram-icon">
+              <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M18 20V10"/><path d="M12 20V4"/><path d="M6 20v-6"/></svg>
+            </div>
+            <span>Analytics</span>
+          </div>
+        </div>
+      </div>
+    </div>
+  </section>
+
+  <!-- Post-Production Pipeline -->
+  <section class="hiw-section">
+    <h2>From Live Show to Podcast</h2>
+
+    <div class="hiw-steps">
+      <div class="hiw-step">
+        <div class="hiw-step-number">9</div>
+        <div class="hiw-step-content">
+          <h3>Multi-Stem Recording</h3>
+          <p>During every show, the system records six separate audio stems simultaneously: host microphone, AI caller voices, music, sound effects, ads, and station idents. Each stem is captured as an independent WAV file with sample-accurate alignment. This gives full control over the final mix — like having a recording studio's multitrack session, not just a flat recording.</p>
+          <div class="hiw-detail-grid">
+            <div class="hiw-detail">
+              <span class="hiw-detail-label">Stems Captured</span>
+              <span class="hiw-detail-value">6 parallel</span>
+            </div>
+            <div class="hiw-detail">
+              <span class="hiw-detail-label">Format</span>
+              <span class="hiw-detail-value">48kHz WAV</span>
+            </div>
+            <div class="hiw-detail">
+              <span class="hiw-detail-label">Sync Method</span>
+              <span class="hiw-detail-value">Time-aligned</span>
+            </div>
+            <div class="hiw-detail">
+              <span class="hiw-detail-label">Architecture</span>
+              <span class="hiw-detail-value">Lock-free I/O</span>
+            </div>
+          </div>
+        </div>
+      </div>
+
+      <div class="hiw-step">
+        <div class="hiw-step-number">10</div>
+        <div class="hiw-step-content">
+          <h3>Dialog Editing in REAPER</h3>
+          <p>Before the automated pipeline runs, the raw stems are loaded into REAPER for dialog editing. A custom Lua script analyzes voice tracks to detect silence gaps — the dead air between caller responses, TTS latency pauses, and gaps where Luke is reading the control room. The script strips these silences and ripple-edits all tracks in sync so ads, idents, and music shift with the dialog cuts. Protected regions marked as ads or idents are preserved — the script knows not to remove silence during an ad break even if the voice tracks are quiet. This tightens a raw two-hour session into a focused episode without cutting any content.</p>
+        </div>
+      </div>
+
+      <div class="hiw-step">
+        <div class="hiw-step-number">11</div>
+        <div class="hiw-step-content">
+          <h3>Post-Production Pipeline</h3>
+          <p>Once the show ends, a 15-step automated pipeline processes the raw stems into a broadcast-ready episode. Ads and sound effects are hard-limited to prevent clipping. The host mic gets a high-pass filter, de-essing, and breath reduction. Voice tracks are compressed — the host gets aggressive spoken-word compression for consistent levels, callers get telephone EQ to sound like real phone calls. All stems are level-matched, music is ducked under dialog and muted during ads, then everything is mixed to stereo with panning and width. A bus compressor glues the final mix together before silence trimming, fades, and EBU R128 loudness normalization.</p>
+          <div class="hiw-detail-grid">
+            <div class="hiw-detail">
+              <span class="hiw-detail-label">Pipeline Steps</span>
+              <span class="hiw-detail-value">15</span>
+            </div>
+            <div class="hiw-detail">
+              <span class="hiw-detail-label">Loudness Target</span>
+              <span class="hiw-detail-value">-16 LUFS</span>
+            </div>
+            <div class="hiw-detail">
+              <span class="hiw-detail-label">Loudness Range</span>
+              <span class="hiw-detail-value">~5.5 LU</span>
+            </div>
+            <div class="hiw-detail">
+              <span class="hiw-detail-label">Output</span>
+              <span class="hiw-detail-value">Stereo MP3</span>
+            </div>
+          </div>
+        </div>
+      </div>
+
+      <div class="hiw-step">
+        <div class="hiw-step-number">12</div>
+        <div class="hiw-step-content">
+          <h3>Automated Publishing</h3>
+          <p>A single command takes a finished episode and handles everything: the audio is transcribed using MLX Whisper running on Apple Silicon GPU to generate full-text transcripts, then an LLM analyzes the transcript to write the episode title, description, and chapter markers with timestamps. The episode is uploaded to the podcast server and directly to YouTube with chapters baked into the description. Chapters and transcripts are attached to the RSS metadata, all media is synced to a global CDN, and social posts are pushed to eight platforms — all from one command.</p>
+          <div class="hiw-detail-grid">
+            <div class="hiw-detail">
+              <span class="hiw-detail-label">Transcription</span>
+              <span class="hiw-detail-value">MLX Whisper (GPU)</span>
+            </div>
+            <div class="hiw-detail">
+              <span class="hiw-detail-label">Metadata</span>
+              <span class="hiw-detail-value">LLM-generated</span>
+            </div>
+            <div class="hiw-detail">
+              <span class="hiw-detail-label">Chapters</span>
+              <span class="hiw-detail-value">Auto-detected</span>
+            </div>
+            <div class="hiw-detail">
+              <span class="hiw-detail-label">Deploy Time</span>
+              <span class="hiw-detail-value">~2 min</span>
+            </div>
+          </div>
+        </div>
+      </div>
+
+      <div class="hiw-step">
+        <div class="hiw-step-number">13</div>
+        <div class="hiw-step-content">
+          <h3>Automated Social Clips</h3>
+          <p>No manual editing, no scheduling tools. After each episode, an LLM reads the full transcript and picks the best moments — funny exchanges, wild confessions, heated debates. Each clip is automatically extracted, transcribed with word-level timestamps, then polished by a second LLM pass that fixes punctuation, capitalization, and misheard words while preserving timing. The clips are rendered as vertical video with speaker-labeled captions and the show's branding. A third LLM writes platform-specific descriptions and hashtags. Then clips are uploaded directly to YouTube Shorts and Bluesky via their APIs, and pushed to Instagram Reels, Facebook Reels, Mastodon, Nostr, LinkedIn, Threads, and TikTok — nine platforms, zero manual work.</p>
+          <div class="hiw-detail-grid">
+            <div class="hiw-detail">
+              <span class="hiw-detail-label">Human Effort</span>
+              <span class="hiw-detail-value">Zero</span>
+            </div>
+            <div class="hiw-detail">
+              <span class="hiw-detail-label">Video Format</span>
+              <span class="hiw-detail-value">1080x1920 MP4</span>
+            </div>
+            <div class="hiw-detail">
+              <span class="hiw-detail-label">Captions</span>
+              <span class="hiw-detail-value">LLM-polished</span>
+            </div>
+            <div class="hiw-detail">
+              <span class="hiw-detail-label">Simultaneous Push</span>
+              <span class="hiw-detail-value">9 platforms</span>
+            </div>
+          </div>
+        </div>
+      </div>
+
+      <div class="hiw-step">
+        <div class="hiw-step-number">14</div>
+        <div class="hiw-step-content">
+          <h3>Global Distribution</h3>
+          <p>Episodes are served through a CDN edge network for fast, reliable playback worldwide. The RSS feed is automatically updated and picked up by Spotify, Apple Podcasts, YouTube, and every other podcast app. The website pulls the live feed to show episodes with embedded playback, full transcripts, and chapter navigation — all served through Cloudflare with edge caching. From recording to available on every platform, the whole pipeline is automated end-to-end.</p>
+          <div class="hiw-detail-grid">
+            <div class="hiw-detail">
+              <span class="hiw-detail-label">Audio Delivery</span>
+              <span class="hiw-detail-value">Global CDN</span>
+            </div>
+            <div class="hiw-detail">
+              <span class="hiw-detail-label">Website</span>
+              <span class="hiw-detail-value">Cloudflare Edge</span>
+            </div>
+            <div class="hiw-detail">
+              <span class="hiw-detail-label">Platforms</span>
+              <span class="hiw-detail-value">5+ directories</span>
+            </div>
+            <div class="hiw-detail">
+              <span class="hiw-detail-label">Feed Format</span>
+              <span class="hiw-detail-value">RSS + Podcast 2.0</span>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+  </section>
+
+  <!-- What makes it different -->
+  <section class="hiw-section">
+    <h2>What Makes This Different</h2>
+    <div class="hiw-features">
+      <div class="hiw-feature">
+        <div class="hiw-feature-icon">
+          <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M20.84 4.61a5.5 5.5 0 0 0-7.78 0L12 5.67l-1.06-1.06a5.5 5.5 0 0 0-7.78 7.78l1.06 1.06L12 21.23l7.78-7.78 1.06-1.06a5.5 5.5 0 0 0 0-7.78z"/></svg>
+        </div>
+        <h3>Not Scripted</h3>
+        <p>Every conversation is improvised. Luke doesn't know what the caller is going to say. The AI doesn't follow a script. It's a real conversation between a human and an AI character who has a life, opinions, and something on their mind.</p>
+      </div>
+      <div class="hiw-feature">
+        <div class="hiw-feature-icon">
+          <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M12 22s8-4 8-10V5l-8-3-8 3v7c0 6 8 10 8 10z"/></svg>
+        </div>
+        <h3>Built From Scratch</h3>
+        <p>This isn't an app with a plugin. Every piece — the caller generator, the voice engine, the control room, the phone system, the post-production pipeline, the publishing automation — was built specifically for this show.</p>
+      </div>
+      <div class="hiw-feature">
+        <div class="hiw-feature-icon">
+          <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="12" cy="12" r="10"/><polyline points="12 6 12 12 16 14"/></svg>
+        </div>
+        <h3>Real Time</h3>
+        <p>Everything happens live. Caller generation, voice synthesis, news lookups, weather checks, phone routing — all in real time during the show. There's no post-production trickery on the caller side. What you hear is what happened.</p>
+      </div>
+      <div class="hiw-feature">
+        <div class="hiw-feature-icon">
+          <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M17 21v-2a4 4 0 0 0-4-4H5a4 4 0 0 0-4 4v2"/><circle cx="9" cy="7" r="4"/><path d="M23 21v-2a4 4 0 0 0-3-3.87"/><path d="M16 3.13a4 4 0 0 1 0 7.75"/></svg>
+        </div>
+        <h3>They Listen to Each Other</h3>
+        <p>Callers aren't isolated — the system matches callers thematically to what's already been discussed. A caller might disagree with the last guy, back someone up, or call in because something another caller said hit close to home. The show tracks energy and pacing so conversations build naturally, not randomly.</p>
+      </div>
+      <div class="hiw-feature">
+        <div class="hiw-feature-icon">
+          <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><polygon points="11 5 6 9 2 9 2 15 6 15 11 19 11 5"/><path d="M19.07 4.93a10 10 0 0 1 0 14.14"/><path d="M15.54 8.46a5 5 0 0 1 0 7.07"/></svg>
+        </div>
+        <h3>Broadcast-Grade Audio</h3>
+        <p>Every episode runs through a 15-step post-production pipeline: stem limiting, high-pass filtering, de-essing, breath reduction, spoken-word compression, telephone EQ, level matching, music ducking with ad muting, stereo imaging, bus compression, and EBU R128 loudness normalization.</p>
+      </div>
+      <div class="hiw-feature">
+        <div class="hiw-feature-icon">
+          <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><polyline points="16 16 12 12 8 16"/><line x1="12" y1="12" x2="12" y2="21"/><path d="M20.39 18.39A5 5 0 0 0 18 9h-1.26A8 8 0 1 0 3 16.3"/></svg>
+        </div>
+        <h3>Fully Automated Pipeline</h3>
+        <p>From recording to your podcast app, the entire pipeline is automated. Post-production kicks off when the show ends, then a publish script handles transcription, AI-generated metadata, chapter detection, CDN sync, and RSS distribution — all with a single command.</p>
+      </div>
+    </div>
+  </section>
+
+  <!-- Post-Production Automation Video -->
+  <section class="hiw-section">
+    <h2>Post-Production in Action</h2>
+    <div class="hiw-hero-card">
+      <video class="hiw-video" controls playsinline preload="metadata" poster="">
+        <source src="https://cdn.lukeattheroost.com/videos/reaper-postprod.mp4" type="video/mp4">
+      </video>
+      <p class="hiw-video-caption">The entire post-production pipeline runs automatically through Reaper scripting. Silence removal, ad ducking, and EBU R128 loudness normalization — all triggered with a single command when the show ends.</p>
+    </div>
+  </section>
+
+  <!-- CTA -->
+  <section class="hiw-section hiw-cta">
+    <p>Want to hear it for yourself?</p>
+    <a href="/" class="hiw-cta-btn">Listen to Episodes</a>
+    <div class="hiw-cta-phone">
+      Or call in live: <strong>208-439-LUKE</strong>
+    </div>
+    <a href="https://ko-fi.com/lukemacneil" target="_blank" rel="noopener" class="hiw-cta-support">Support the Show</a>
+  </section>
+
+  </main>
+
+  <footer class="footer"></footer>
+  <script src="js/footer.js"></script>
+</body>
+</html>