From 9071ed36d372dbcf32135bf135d184025dedf324 Mon Sep 17 00:00:00 2001 From: tcpsyn Date: Fri, 14 Aug 2026 04:23:53 -0500 Subject: [PATCH] Track design and implementation plans MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Seven plan documents covering the website JS infrastructure, show theme, caller quality overhaul, cost dashboard, the Alpine relocation, and caller variety plus Devon's search — the record of why the current architecture looks the way it does. Plus the press release draft. Co-Authored-By: Claude Opus 5 --- .../2026-03-16-website-js-infrastructure.md | 719 ++++++++++++++++ docs/plans/2026-03-17-show-theme.md | 335 ++++++++ .../2026-03-30-caller-quality-overhaul.md | 300 +++++++ .../plans/2026-04-02-cost-dashboard-design.md | 107 +++ ...026-04-02-cost-dashboard-implementation.md | 810 ++++++++++++++++++ .../2026-05-31-alpine-relocation-design.md | 78 ++ ...-caller-variety-and-devon-search-design.md | 56 ++ press_release.md | 55 ++ 8 files changed, 2460 insertions(+) create mode 100644 docs/plans/2026-03-16-website-js-infrastructure.md create mode 100644 docs/plans/2026-03-17-show-theme.md create mode 100644 docs/plans/2026-03-30-caller-quality-overhaul.md create mode 100644 docs/plans/2026-04-02-cost-dashboard-design.md create mode 100644 docs/plans/2026-04-02-cost-dashboard-implementation.md create mode 100644 docs/plans/2026-05-31-alpine-relocation-design.md create mode 100644 docs/plans/2026-06-02-caller-variety-and-devon-search-design.md create mode 100644 press_release.md diff --git a/docs/plans/2026-03-16-website-js-infrastructure.md b/docs/plans/2026-03-16-website-js-infrastructure.md new file mode 100644 index 0000000..48397fe --- /dev/null +++ b/docs/plans/2026-03-16-website-js-infrastructure.md @@ -0,0 +1,719 @@ +# Website JS Infrastructure, SEO, Shared Components & Content Fixes + +> **For Claude:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task. + +**Goal:** Fix JS duplication, add worker-level social meta injection, standardize analytics proxying, improve security and UX, and clean up content/SEO issues across lukeattheroost.com. + +**Architecture:** Extract shared footer into `js/footer.js`, extract shared audio player into `js/player.js`, enhance `_worker.js` to intercept social crawler requests and inject episode-specific meta tags, switch all subpages to proxied Plausible analytics, add episode pagination, fix XSS surfaces, and clean up sitemap/clips data. + +**Tech Stack:** Vanilla JS, Cloudflare Pages Worker (ES module), static HTML, XML sitemap + +--- + +### Task 1: Create shared footer component (`js/footer.js`) + +**Files:** +- Create: `website/js/footer.js` + +**Step 1: Write footer.js** + +The footer HTML is duplicated across 7 pages (index.html:265-306, episode.html:95-136, clips.html:68-109, stats.html, privacy.html, terms.html, how-it-works.html). Extract the footer from `index.html` as the canonical version. + +```js +function initFooter() { + const footer = document.querySelector('.footer'); + if (!footer) return; + + footer.innerHTML = ` +
+ Home + How It Works + Clips + Stats +
+
+ Listen On +
+ + + + +
+
+
+ Follow +
+ + + + + + + + + + +
+
+
+ More from Luke +
+ MacNeil Media Group + Photography Prints + YouTube +
+
+

Support the Show

+

Sales & Collaboration: luke@lukeattheroost.com

+

© 2026 Luke at the Roost · Privacy Policy · Terms of Service · System Status

+ `; +} + +initFooter(); +``` + +**Step 2: Commit** + +```bash +git add website/js/footer.js +git commit -m "Add shared footer component (js/footer.js)" +``` + +--- + +### Task 2: Replace inline footers with shared component + +**Files:** +- Modify: `website/index.html` — replace lines 265-306 (inline footer content) with empty `
`, add `` before closing `` +- Modify: `website/episode.html` — replace lines 95-136 with empty footer, add script tag +- Modify: `website/clips.html` — replace lines 68-109 with empty footer, add script tag +- Modify: `website/stats.html` — replace inline footer with empty footer, add script tag +- Modify: `website/privacy.html` — replace inline footer with empty footer, add script tag +- Modify: `website/terms.html` — replace inline footer with empty footer, add script tag +- Modify: `website/how-it-works.html` — replace inline footer with empty footer, add script tag + +**Step 1: Update each page** + +For each of the 7 HTML files: +1. Replace the entire `
...
` block with just `
` +2. Add `` near the end of ``, before any page-specific scripts + +Note: index.html's footer has slightly different nav links (no "Home" link since it IS home). The shared footer includes "Home" which is fine — clicking Home on the homepage just reloads it. + +**Step 2: Verify no footer content remains inline** + +Search for `footer-icons-label` in all HTML files — should only appear in `js/footer.js`. + +**Step 3: Commit** + +```bash +git add website/index.html website/episode.html website/clips.html website/stats.html website/privacy.html website/terms.html website/how-it-works.html +git commit -m "Replace inline footers with shared footer.js component" +``` + +--- + +### Task 3: Extract shared audio player module (`js/player.js`) + +**Files:** +- Create: `website/js/player.js` + +The audio player code is duplicated: `app.js:1-11,14-23,143-226` and `episode.html:159-346` (inline `` then `` +- Create: `website/js/episode.js` — episode-specific logic extracted from episode.html inline script (load episode from RSS, populate header, transcript loading, play button) +- Modify: `website/index.html` — add `` before `app.js` + +**Step 1: Refactor app.js** + +Remove from app.js: +- Lines 1-11 (element lookups — now in player.js) +- Lines 14-23 (formatTime — now in player.js) +- Lines 173-226 (audio event listeners, updatePlayIcons, playerPlayBtn click, playerProgress click — now in player.js) + +Keep the `currentEpisodeCard` variable and the card-specific icon toggling in `updatePlayIcons`. Since player.js handles the sticky player icons, app.js only needs to handle the episode card icons. Add a listener: + +```js +audio.addEventListener('play', () => { + if (currentEpisodeCard) { + const btn = currentEpisodeCard.querySelector('.episode-play-btn'); + if (btn) { btn.innerHTML = pauseSVG; btn.classList.add('playing'); } + } +}); +audio.addEventListener('pause', () => { + if (currentEpisodeCard) { + const btn = currentEpisodeCard.querySelector('.episode-play-btn'); + if (btn) { btn.innerHTML = playSVG; btn.classList.remove('playing'); } + } +}); +audio.addEventListener('ended', () => { + if (currentEpisodeCard) { + const btn = currentEpisodeCard.querySelector('.episode-play-btn'); + if (btn) { btn.innerHTML = playSVG; btn.classList.remove('playing'); } + } +}); +``` + +**Step 2: Create episode.js** + +Extract episode-specific logic from episode.html inline script. Use the global `audio`, `playerTitle`, `stickyPlayer` from player.js. Include: `formatDate`, `parseDuration`, `stripHtml`, slug parsing, `loadEpisode()`. + +**Step 3: Update HTML script tags** + +In `index.html`, change script loading order: +```html + + + + + +``` + +In `episode.html`, replace inline ` + + +``` + +**Step 4: Commit** + +```bash +git add website/js/app.js website/js/player.js website/js/episode.js website/index.html website/episode.html +git commit -m "Deduplicate audio player code into shared player.js module" +``` + +--- + +### Task 5: Fix Plausible analytics — switch all subpages to proxied version + +**Files:** +- Modify: `website/episode.html` line 51-52 +- Modify: `website/clips.html` line 43-44 +- Modify: `website/stats.html` line 43-44 +- Modify: `website/privacy.html` line 37-38 +- Modify: `website/terms.html` line 37-38 +- Modify: `website/how-it-works.html` line 66-67 + +**Step 1: In each file, replace the direct Plausible script tag** + +Replace: +```html + + +``` + +With: +```html + + +``` + +**Step 2: Verify** + +Grep for `plausible.macneilmediagroup.com` in HTML files — should return 0 matches (only `_worker.js` should have it). + +**Step 3: Commit** + +```bash +git add website/episode.html website/clips.html website/stats.html website/privacy.html website/terms.html website/how-it-works.html +git commit -m "Switch all subpages to proxied Plausible analytics" +``` + +--- + +### Task 6: Worker — social crawler meta tag injection for episode pages + +**Files:** +- Modify: `website/_worker.js` + +**Step 1: Add social crawler detection and meta injection** + +Before the `return env.ASSETS.fetch(request)` line (line 90), add a handler for `/episode.html` requests from social crawlers: + +```js +// 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"); + + // Fetch RSS to find episode info + try { + const feedResp = await fetch("https://podcast.macneilmediagroup.com/@LukeAtTheRoost/feed.xml", { + signal: AbortSignal.timeout(5000), + }); + if (feedResp.ok) { + const feedXml = await feedResp.text(); + + // Simple string-based extraction (no DOM parser in Workers) + const items = feedXml.split(""); + let title = ""; + let description = ""; + + for (let i = 1; i < items.length; i++) { + const item = items[i]; + const linkMatch = item.match(/(.*?)<\/link>/); + if (linkMatch) { + const itemSlug = linkMatch[1].split("/episodes/").pop()?.replace(/\/$/, ""); + if (itemSlug === slug) { + const titleMatch = item.match(/(.*?)<\/title>/); + title = titleMatch ? titleMatch[1].replace(/<!\[CDATA\[|\]\]>/g, "").trim() : ""; + const descMatch = item.match(/<description>(.*?)<\/description>/s); + description = descMatch + ? descMatch[1].replace(/<!\[CDATA\[|\]\]>/g, "").replace(/<[^>]+>/g, "").trim().slice(0, 200) + : ""; + break; + } + } + } + + if (title) { + // Fetch the actual HTML page + const pageResp = await env.ASSETS.fetch(request); + let html = await pageResp.text(); + + const escTitle = title.replace(/&/g, "&").replace(/"/g, """).replace(/</g, "<"); + const escDesc = description.replace(/&/g, "&").replace(/"/g, """).replace(/</g, "<"); + const canonicalUrl = `https://lukeattheroost.com/episode.html?slug=${slug}`; + + // Replace placeholder meta tags + 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` + ); + + return new Response(html, { + status: 200, + headers: { "Content-Type": "text/html;charset=UTF-8" }, + }); + } + } + } catch (e) { + // Fall through to static page + } + } +} +``` + +**Step 2: Commit** + +```bash +git add website/_worker.js +git commit -m "Add social crawler meta tag injection for episode pages" +``` + +--- + +### Task 7: Security — sanitize innerHTML XSS surfaces + +**Files:** +- Modify: `website/js/episode.js` (created in Task 4) +- Modify: `website/js/app.js` + +**Step 1: Fix episode description XSS in episode.js** + +In the `loadEpisode` function, change line that sets description: +```js +// BEFORE (XSS): +document.getElementById('ep-desc').innerHTML = episode.description || ''; + +// AFTER (safe): +document.getElementById('ep-desc').textContent = stripHtml(episode.description || ''); +``` + +**Step 2: Fix title escaping in app.js episode card rendering** + +In `renderEpisodes()`, the title goes into a `data-title` attribute with basic `.replace(/"/g, '"')`. Use the `escapeHTML` pattern from clips.js. Add a helper at top of app.js: + +```js +function escapeAttr(str) { + return str.replace(/&/g, '&').replace(/"/g, '"').replace(//g, '>'); +} +``` + +Then change line 125: +```js +// BEFORE: +data-title="${ep.title.replace(/"/g, '"')}" + +// AFTER: +data-title="${escapeAttr(ep.title)}" +``` + +Also escape the title in the aria-label and visible title: +```js + + + +``` + +**Step 2: Add CSS for theme bar** + +In `frontend/css/style.css`, add styles for the theme bar. Place near other header styles: + +```css +.theme-bar { + display: flex; + align-items: center; + gap: 6px; + padding: 4px 12px; + background: rgba(255, 255, 255, 0.05); + border-radius: 6px; +} + +.theme-label { + font-size: 0.8rem; + color: #aaa; + white-space: nowrap; +} + +.theme-input { + background: rgba(255, 255, 255, 0.08); + border: 1px solid rgba(255, 255, 255, 0.15); + border-radius: 4px; + color: #fff; + padding: 4px 8px; + font-size: 0.85rem; + width: 200px; +} + +.theme-input:focus { + outline: none; + border-color: #f5a623; +} + +.theme-input.active { + border-color: #f5a623; + background: rgba(245, 166, 35, 0.1); +} + +.theme-btn { + padding: 4px 10px; + border-radius: 4px; + border: none; + cursor: pointer; + font-size: 0.8rem; +} + +.theme-btn.set { + background: #f5a623; + color: #000; +} + +.theme-btn.set:hover { + background: #e6991a; +} + +.theme-btn.clear { + background: rgba(255, 255, 255, 0.1); + color: #aaa; + padding: 4px 6px; +} + +.theme-btn.clear:hover { + background: rgba(255, 80, 80, 0.3); + color: #ff5050; +} +``` + +**Step 3: Add JS for theme set/clear** + +In `frontend/js/app.js`, add theme management functions and wire up event listeners. Add near other initialization code: + +```javascript +async function loadShowTheme() { + try { + const res = await fetch('/api/show-theme'); + const data = await res.json(); + const input = document.getElementById('show-theme-input'); + const setBtn = document.getElementById('set-theme-btn'); + const clearBtn = document.getElementById('clear-theme-btn'); + if (data.theme) { + input.value = data.theme; + input.classList.add('active'); + setBtn.classList.add('hidden'); + clearBtn.classList.remove('hidden'); + } + } catch (e) { + console.error('Failed to load show theme:', e); + } +} + +async function setShowTheme() { + const input = document.getElementById('show-theme-input'); + const theme = input.value.trim(); + if (!theme) return; + try { + const res = await fetch('/api/show-theme', { + method: 'POST', + headers: { 'Content-Type': 'application/json' }, + body: JSON.stringify({ theme }) + }); + const data = await res.json(); + if (data.theme) { + input.classList.add('active'); + document.getElementById('set-theme-btn').classList.add('hidden'); + document.getElementById('clear-theme-btn').classList.remove('hidden'); + } + } catch (e) { + console.error('Failed to set show theme:', e); + } +} + +async function clearShowTheme() { + try { + await fetch('/api/show-theme', { + method: 'POST', + headers: { 'Content-Type': 'application/json' }, + body: JSON.stringify({ theme: '' }) + }); + const input = document.getElementById('show-theme-input'); + input.value = ''; + input.classList.remove('active'); + document.getElementById('set-theme-btn').classList.remove('hidden'); + document.getElementById('clear-theme-btn').classList.add('hidden'); + } catch (e) { + console.error('Failed to clear show theme:', e); + } +} +``` + +Wire up event listeners (in the DOMContentLoaded or init block): + +```javascript +document.getElementById('set-theme-btn').addEventListener('click', setShowTheme); +document.getElementById('clear-theme-btn').addEventListener('click', clearShowTheme); +document.getElementById('show-theme-input').addEventListener('keydown', (e) => { + if (e.key === 'Enter') setShowTheme(); +}); +loadShowTheme(); +``` + +**Step 4: Test in browser** + +1. Open http://localhost:8000 +2. Type a theme in the input, click Set — input should highlight amber, Set button hides, X button appears +3. Click X — input clears, reverts to normal state +4. Refresh page — theme should persist (loaded from API) + +**Step 5: Commit** + +```bash +git add frontend/index.html frontend/css/style.css frontend/js/app.js +git commit -m "Add show theme input to header bar" +``` + +--- + +### Task 5: Clear theme on new session + +**Files:** +- Modify: `backend/main.py` (session reset logic) + +**Step 1: Find session reset and ensure theme clears** + +Search for where `session = Session()` is called (the new session endpoint). The theme field is already in `__init__` with default `""`, so creating a new Session automatically clears it. No code change needed here — but verify the frontend reloads the theme on new session. + +In the frontend, find the new session button handler and add `loadShowTheme()` after the session reset call completes, so the UI reflects the cleared theme. + +**Step 2: Commit (if any changes needed)** + +```bash +git add frontend/js/app.js +git commit -m "Reload theme state on new session" +``` diff --git a/docs/plans/2026-03-30-caller-quality-overhaul.md b/docs/plans/2026-03-30-caller-quality-overhaul.md new file mode 100644 index 0000000..68c0622 --- /dev/null +++ b/docs/plans/2026-03-30-caller-quality-overhaul.md @@ -0,0 +1,300 @@ +# Caller Quality Overhaul — Implementation Plan + +> **For Claude:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task. + +**Goal:** Make every caller interesting, layered, and conversationally driven — with specific details to reveal when pressed, strong opinions, and stories that sustain 10+ exchanges without going flat. + +**Architecture:** Four interconnected changes: (1) LLM-generated updates for returning callers, (2) hidden layers in CallerBackground, (3) rebalanced caller prompt from reactive to driven, (4) massively expanded topic pools with more edgy/interesting/specific content. The alien abduction call (Bev, ep45) is the gold standard — professional expertise, progressive reveals, specific details, caller-driven energy. + +**Tech Stack:** Python, OpenRouter LLM API, existing CallerBackground dataclass + +--- + +## Task 1: Add Hidden Layers to CallerBackground + +The core structural change. Callers currently get ONE situation paragraph. When the host digs in, there's nothing underneath. Add 3 fields to CallerBackground that give the caller ammunition for deeper conversations. + +**Files:** +- Modify: `backend/main.py` — CallerBackground dataclass (~line 6140), LLM background generation prompt (~line 5310) + +**Step 1: Add fields to CallerBackground dataclass** + +Find the CallerBackground dataclass and add three new fields: + +```python +hidden_layers: list[str] = field(default_factory=list) # 3 details they haven't mentioned yet — the juicy stuff underneath +burning_opinion: str = "" # Something they're dying to say — will bring up even without being asked +stakes: str = "" # What's at risk for them — why this matters, what happens if nothing changes +``` + +**Step 2: Update the LLM background generation prompt** + +In the JSON output spec of the background generation prompt (~line 5322), add: + +``` +- "hidden_layers": A list of exactly 3 specific details the caller HASN'T mentioned yet but will reveal when pressed. These are the layers underneath the surface story. Think: the part they're embarrassed about, the complication they haven't admitted, the thing that happened AFTER the main event, the detail that changes everything. Each should be 1-2 sentences and SPECIFIC enough to sustain a follow-up question. Example: if the surface story is "my neighbor stole my mail" — layer 1 might be "the stolen mail included a paternity test result," layer 2 might be "the neighbor is actually her ex-husband's new girlfriend," layer 3 might be "she's been retaliating by feeding the neighbor's cat so it likes her better." +- "burning_opinion": ONE thing this caller is dying to say — a strong opinion, a controversial take, something they'll volunteer even without being asked. This is what makes them INTERESTING to talk to. Not a generic feeling ("I'm frustrated") but a specific, arguable position ("I think what she did was right and I'd do it again"). Make it provocative enough that the host would want to push back. +- "stakes": What's at risk for this caller. Why does this matter? What happens if nothing changes? "My sister won't talk to me" is weak. "If I don't fix this by Thursday, my sister is telling our parents about the money I took and I'll get cut out of the will" is strong. Real consequences, real deadlines, real pressure. +``` + +**Step 3: Update the prompt's "WHAT MAKES A GOOD CALLER" section** + +Add to the existing guidance: + +``` +DEPTH TEST: Before finalizing, ask yourself — if the host asks "tell me more about that" THREE times, does the caller have three genuinely new, interesting things to reveal? If not, the story is too shallow. Add complications, secrets, or consequences that create layers. +``` + +**Step 4: Thread hidden_layers into the caller system prompt** + +In `get_caller_prompt()` (~line 6015), add a section that feeds hidden layers to the caller: + +```python +# Hidden layers — details to reveal when pressed +layers_block = "" +if caller.get('hidden_layers'): + layers = caller['hidden_layers'] + layers_block = f""" +DETAILS YOU HAVEN'T MENTIONED YET (reveal these naturally when Luke asks follow-up questions or digs deeper — don't dump them all at once, let them come out one at a time as the conversation develops): +- {layers[0] if len(layers) > 0 else ''} +- {layers[1] if len(layers) > 1 else ''} +- {layers[2] if len(layers) > 2 else ''} +""" + +# Burning opinion — something they're dying to say +opinion_block = "" +if caller.get('burning_opinion'): + opinion_block = f""" +SOMETHING YOU'RE DYING TO SAY: {caller['burning_opinion']} +You'll bring this up when there's a natural opening — you don't need to be asked. This is YOUR call and you have a POINT to make. +""" + +# Stakes — why this matters +stakes_block = "" +if caller.get('stakes'): + stakes_block = f""" +WHAT'S AT STAKE: {caller['stakes']} +This isn't abstract — there are real consequences. Mention this when it's relevant. It's why you're calling NOW instead of just thinking about it. +""" +``` + +Insert these blocks into the prompt after `{story_block}`. + +**Step 5: Commit** + +--- + +## Task 2: LLM-Generated Updates for Returning Callers + +Currently `_generate_returning_caller_background()` gives returning callers their old summaries and a one-line "something has changed." The dialog model has to improvise an update from nothing. Fix this by using the LLM to generate a specific, interesting new development. + +**Files:** +- Modify: `backend/main.py` — `_generate_returning_caller_background()` (~line 4722) + +**Step 1: Add LLM story continuation to returning caller background** + +After building `prev_section` with call history (~line 4764), add an async LLM call to generate a new development: + +```python +# Generate a specific new development via LLM +update_prompt = f"""A returning caller on a late-night radio show is calling back. Here's their history: + +NAME: {regular['name']}, {age}, {gender} +JOB: {job} +PREVIOUS CALLS: +{chr(10).join(f'- {c["summary"]}' for c in prev_calls[-3:])} + +Generate a SPECIFIC new development in their ongoing situation. Something has changed, escalated, or taken an unexpected turn since their last call. This should be: +- Surprising but believable — a natural next chapter, not a soap opera twist +- Specific with names, details, and concrete events +- Interesting enough to sustain a 5-10 minute conversation +- Connected to their previous calls but moving the story FORWARD + +Also generate 3 hidden layers (details they'll reveal when pressed) and a burning opinion (something they're dying to say about how things have developed). + +Respond with JSON: +{{ + "new_development": "2-3 sentences describing what happened since their last call", + "hidden_layers": ["detail 1", "detail 2", "detail 3"], + "burning_opinion": "their strong take on the situation now" +}} + +Output ONLY valid JSON, no markdown fences.""" +``` + +Make this an async function. Call the LLM, parse the JSON, and inject the new_development into `prev_section` and the hidden_layers/burning_opinion into the caller's background data. + +**Step 2: Update the returning caller story_block in get_caller_prompt()** + +Change the returning caller `story_block` (~line 6056) from the passive "something has developed" to: + +```python +story_block = f"""YOUR STORY: You're calling back about your ongoing situation. Here's what's NEW since your last call — this is why you're calling tonight: + +{{new_development}} + +You have SPECIFIC things to talk about. Don't just vaguely reference "things have changed" — tell Luke EXACTLY what happened. You're calling because this new development is significant and you need to talk it through. You have details, you have feelings about it, and you have a point you want to make. + +When Luke asks about your previous calls, give him the quick version — then get to what's NEW. The update is why you're here tonight.""" +``` + +**Step 3: Commit** + +--- + +## Task 3: Rebalance Caller Prompt — Driven, Not Passive + +The current prompt over-emphasizes reactivity ("GO WHERE THE HOST TAKES YOU", "Let him drive"). This makes callers passive. Real compelling callers have their own agenda AND respond to the host. + +**Files:** +- Modify: `backend/main.py` — `get_caller_prompt()` (~line 6015) + +**Step 1: Rewrite the "GO WHERE THE HOST TAKES YOU" section** + +Replace the current passive framing (~line 6094) with a balanced version: + +``` +GO WITH THE HOST BUT BRING YOUR OWN ENERGY. When Luke pushes you in a direction, challenges you, calls you out, or plays devil's advocate — engage with it. Don't shut down, don't deflect. If he says "but isn't that really about your dad?" — sit with that. BUT you're not a passive interview subject. You called because you have something to SAY. Between his questions, volunteer details he didn't ask for. Share the part you're embarrassed about. Drop the detail that changes everything. Push back when you disagree. Ask HIM what he thinks. The best callers are the ones who give the host material AND have their own momentum. You're not here to answer questions — you're here to have a CONVERSATION. +``` + +**Step 2: Update the "REACT TO LUKE" section** + +Change from pure reactivity (~line 6096) to a balance: + +``` +REACT TO LUKE — BUT KEEP YOUR MOMENTUM: Your first sentence should respond to what Luke just said. But your SECOND sentence should add something new — a detail he didn't ask for, a complication, a related story, your opinion. Don't just answer and stop. Answer, then GIVE HIM MORE. If he asks "what happened next?" — don't just tell him what happened next. Tell him what happened next AND how it made you feel AND the part you haven't told anyone yet. Fill the space. Dead air is your enemy. +``` + +**Step 3: Add a "WHEN LUKE ASKS FOR DETAILS" section** + +Add a new section after the REACT TO LUKE block: + +``` +WHEN LUKE ASKS FOR DETAILS — DELIVER. If Luke asks "tell me more about that" or "what do you mean?" or pushes for specifics — this is your moment. Don't give a vague one-sentence answer. Paint the picture. Who was there? What did they actually say? What were you doing when it happened? What did the room look like? What was going through your head? Specifics are what make a call memorable. "She was mad" is boring. "She threw her drink at the wall and said 'I knew you'd do this, you're just like your father'" is radio gold. ALWAYS have a specific answer ready — if Luke is digging, it means he's interested. Reward that interest with detail. +``` + +**Step 4: Commit** + +--- + +## Task 4: Massively Expand Topic Pools + +The current pools have good coverage but need more entries in the categories that produce the best calls: morally complex situations, sex/relationship drama, genuinely weird experiences, and callers with real questions about their lives. The alien abduction call worked because it was SPECIFIC, WEIRD, and the caller had EXPERTISE. + +**Files:** +- Modify: `backend/main.py` — PROBLEMS, STORIES, WEIRD, ADVICE, GOSSIP, TOPIC_CALLIN pools + +**Step 1: Add 80+ new PROBLEMS entries** + +Focus on: moral dilemmas with no clear right answer, sex/relationship situations that are messy and specific, workplace drama with real stakes, family situations with complications. Every entry should pass the "tell me more" test — can you ask 3 follow-up questions and get interesting answers? + +Categories to emphasize: +- **Moral dilemmas**: situations where both sides have a point, where doing the "right" thing has real costs +- **Sex/relationship mess**: not generic "my partner cheated" but specific, awkward, funny situations with details +- **Money/ethics**: found money, inheritance drama, business partner disputes, discovered fraud +- **Secrets discovered**: found out something they shouldn't know, now they have to decide what to do with it +- **Professional expertise callers**: people calling about weird things they encountered AT WORK (like Bev the nurse with the alien patient) — medical, legal, construction, teaching, law enforcement perspectives + +**Step 2: Add 60+ new WEIRD entries** + +The WEIRD pool produces the best calls when it's specific enough. Focus on: +- Genuinely unexplainable personal experiences (not just "something spooky happened") +- Bizarre neighbor/coworker behavior with specific ongoing patterns +- Objects/places that don't behave normally +- Coincidences too specific to be coincidence +- Things they've noticed that nobody else seems to see +- Callers who have developed elaborate theories about everyday phenomena + +**Step 3: Add 60+ new STORIES entries** + +Focus on stories where the caller was INVOLVED, not just an observer: +- Times they did something they can't believe they did +- Situations that escalated beyond all reason +- Encounters with strangers that changed their perspective +- Times they were absolutely, completely wrong about something +- Situations where they were the bad guy and know it +- Things they got away with that they probably shouldn't have + +**Step 4: Add 40+ new ADVICE entries** + +Real questions people would actually call a radio show about: +- "Am I wrong for..." situations with genuine ambiguity +- Situations where they've already decided but want validation +- Timing/approach questions ("how do I tell my wife...") +- Callers who are about to do something and want a gut check +- Callers asking about the host's opinion on something specific and controversial + +**Step 5: Add 40+ new GOSSIP entries** + +Gossip works best when the caller has DETAILS and opinions: +- Discovered something about someone in their life that changes everything +- Workplace gossip with real consequences if it gets out +- Small-town drama with escalating stakes +- Things overheard that they probably shouldn't have heard + +**Step 6: Commit** + +--- + +## Task 5: Increase Response Budget for Substantive Answers + +The current budget gives 15% of standard calls only 450 tokens / 3 sentences. When a caller has a great story, 3 sentences isn't enough. Shift the distribution to give callers more room to breathe, especially early in the call. + +**Files:** +- Modify: `backend/main.py` — `_pick_response_budget()` (~line 8280) + +**Step 1: Adjust default response budget distribution** + +```python +# Default distribution — give callers room to tell their story +roll = random.random() +if roll < 0.10: + return 500, 4 # 10% — quick response (was 15% / 3 sentences) +elif roll < 0.35: + return 600, 5 # 25% — normal conversation (was 30% / 4 sentences) +elif roll < 0.65: + return 700, 6 # 30% — room to breathe (was 30% / 5 sentences) +else: + return 800, 7 # 35% — telling a story or riffing (was 25% / 6 sentences) +``` + +Also bump up shape-specific budgets proportionally. + +**Step 2: Increase MIN_RESPONSE_WORDS** + +Change from 20 to 30: +```python +MIN_RESPONSE_WORDS = 30 # Retry if response is shorter than this +``` + +**Step 3: Commit** + +--- + +## Task 6: Quality Review and Integration Test + +Read through all changes, verify they integrate cleanly, and test with a simulated caller generation. + +**Files:** +- Read: all modified files + +**Step 1: Verify CallerBackground field additions parse correctly** + +Run a test background generation to make sure the new fields (hidden_layers, burning_opinion, stakes) are populated by the LLM and parsed into the dataclass. + +**Step 2: Verify returning caller LLM update generates properly** + +Test with an existing regular (e.g., Shonda) to confirm the LLM generates a specific new development. + +**Step 3: Verify the new prompt sections render correctly in get_caller_prompt()** + +Check that hidden_layers, burning_opinion, and stakes blocks appear in the system prompt for a caller that has them. + +**Step 4: Restart server and verify no import/syntax errors** + +```bash +pkill -f "uvicorn backend.main:app" +/Users/lukemacneil/code/ai-podcast/venv/bin/python -m uvicorn backend.main:app --reload --reload-dir backend --host 0.0.0.0 --port 8000 +``` + +**Step 5: Commit** diff --git a/docs/plans/2026-04-02-cost-dashboard-design.md b/docs/plans/2026-04-02-cost-dashboard-design.md new file mode 100644 index 0000000..69c1658 --- /dev/null +++ b/docs/plans/2026-04-02-cost-dashboard-design.md @@ -0,0 +1,107 @@ +# Cost Dashboard Design + +## Overview + +A dedicated cost analytics dashboard at `/costs` that visualizes LLM and TTS spending across sessions with time-range filtering, model/category breakdowns, and drill-down into individual sessions and calls. + +## Architecture + +- **Route:** `/costs` served by FastAPI, standalone page matching the control panel's dark theme +- **Database:** SQLite (`data/costs.db`) for cross-session aggregation +- **Charts:** Chart.js (vanilla JS, no framework) +- **Data migration:** On first run, import existing `data/cost_reports/*.json` into SQLite +- **Dual write:** `cost_tracker.py` continues writing JSON reports (backward compat) and also writes to SQLite going forward + +## Database Schema + +### `sessions` +| Column | Type | Description | +|--------|------|-------------| +| id | TEXT PK | Session ID | +| started_at | TIMESTAMP | Session start time | +| total_cost | REAL | Total cost USD | +| llm_cost | REAL | LLM cost USD | +| tts_cost | REAL | TTS cost USD | +| total_llm_calls | INTEGER | Number of LLM calls | +| total_tts_calls | INTEGER | Number of TTS calls | +| total_tokens | INTEGER | Total tokens used | +| prompt_tokens | INTEGER | Prompt tokens | +| completion_tokens | INTEGER | Completion tokens | + +### `llm_calls` +| Column | Type | Description | +|--------|------|-------------| +| id | INTEGER PK | Auto-increment | +| session_id | TEXT FK | References sessions.id | +| timestamp | TIMESTAMP | Call time | +| category | TEXT | background_gen, caller_dialog, devon_monitor, etc. | +| model | TEXT | Model identifier | +| prompt_tokens | INTEGER | Prompt tokens | +| completion_tokens | INTEGER | Completion tokens | +| cost | REAL | Cost USD | +| caller_name | TEXT | Caller name (nullable) | +| latency_ms | REAL | Response latency | + +### `tts_calls` +| Column | Type | Description | +|--------|------|-------------| +| id | INTEGER PK | Auto-increment | +| session_id | TEXT FK | References sessions.id | +| timestamp | TIMESTAMP | Call time | +| provider | TEXT | Inworld, ElevenLabs, etc. | +| voice | TEXT | Voice ID | +| char_count | INTEGER | Characters synthesized | +| cost | REAL | Cost USD | + +## API Endpoints + +All new endpoints under `/api/costs/`: + +| Endpoint | Description | +|----------|-------------| +| `GET /api/costs/summary?period=today\|week\|month\|all` | Aggregated totals: spend, LLM/TTS split, call count, tokens, avg cost/session, % change vs previous period | +| `GET /api/costs/timeline?period=week\|month\|all&group_by=session\|day` | Time-series for line chart (cost over time) | +| `GET /api/costs/models?period=week\|month\|all` | Per-model breakdown for pie/bar charts | +| `GET /api/costs/categories?period=week\|month\|all` | Per-category breakdown (background_gen, caller_dialog, etc.) | +| `GET /api/costs/sessions?period=week\|month\|all` | Session list with totals, sortable | +| `GET /api/costs/session/{id}` | Single session detail: per-caller costs, expensive calls, recommendations | +| `GET /api/costs/expensive?period=week\|month\|all&limit=10` | Top N most expensive individual calls | + +Existing `/api/costs` (live session) endpoint remains unchanged. + +## Dashboard Layout + +### Header +Time range selector tabs: Today / This Week / This Month / All Time. Clicking any tab refreshes all charts. + +### Row 1 — Summary Cards (4 across) +- **Total Spend** with % change vs previous period +- **LLM / TTS Split** showing both values +- **Total Sessions** in period +- **Avg Cost Per Session** + +### Row 2 — Two charts side by side +- **Left: Cost Over Time** — line chart, x-axis sessions or days, y-axis dollars. LLM and TTS as separate lines. +- **Right: Cost by Model** — doughnut chart with legend showing dollar amounts. + +### Row 3 — Two charts side by side +- **Left: Cost by Category** — horizontal bar chart (background_gen, caller_dialog, devon_monitor, etc.) +- **Right: Cost Per Session Trend** — bar chart, each bar a session, colored above/below average. + +### Row 4 — Tables +- **Most Expensive Calls** — top 10 LLM calls (model, category, caller, tokens, cost, timestamp) +- **Session List** — all sessions, sortable by date/cost, clickable for detail view. + +### Session Detail View (click-through) +- Per-caller cost breakdown +- Call-by-call timeline +- Recommendations from existing `_generate_recommendations()` logic + +## Visual Style +Matches the control panel's existing dark theme. Same fonts, colors, card styles. + +## What's NOT in v1 +- SignalWire cost tracking (future addition) +- Real-time WebSocket updates (polling on page load is sufficient) +- Cost alerts/budgets +- Export to CSV diff --git a/docs/plans/2026-04-02-cost-dashboard-implementation.md b/docs/plans/2026-04-02-cost-dashboard-implementation.md new file mode 100644 index 0000000..acc3e3d --- /dev/null +++ b/docs/plans/2026-04-02-cost-dashboard-implementation.md @@ -0,0 +1,810 @@ +# Cost Dashboard Implementation Plan + +> **For Claude:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task. + +**Goal:** Build a cost analytics dashboard at `/costs` that visualizes LLM and TTS spending across sessions with time-range filtering, charts, and drill-down. + +**Architecture:** SQLite database (`data/costs.db`) stores all cost records. Existing JSON reports are imported on first run. `cost_tracker.py` dual-writes to both JSON and SQLite. New API endpoints serve aggregated data. Standalone HTML page with Chart.js renders the dashboard. + +**Tech Stack:** Python/FastAPI, SQLite, Chart.js (CDN), vanilla JS, CSS custom properties matching existing dark theme. + +--- + +### Task 1: SQLite Database Module + +**Files:** +- Create: `backend/services/cost_db.py` + +**Step 1: Create the database module with schema** + +Create `backend/services/cost_db.py` with: +- `init_db(db_path)` — creates tables if not exist, returns connection +- `import_json_reports(db_path, reports_dir)` — scans `data/cost_reports/*.json`, imports any sessions not already in the DB +- `get_db()` — returns a connection to `data/costs.db`, calls `init_db` on first use + +```python +import json +import sqlite3 +from datetime import datetime, timedelta +from pathlib import Path + +DB_PATH = Path(__file__).parent.parent.parent / "data" / "costs.db" +REPORTS_DIR = Path(__file__).parent.parent.parent / "data" / "cost_reports" + +_connection = None + +SCHEMA = """ +CREATE TABLE IF NOT EXISTS sessions ( + id TEXT PRIMARY KEY, + started_at TIMESTAMP, + total_cost REAL DEFAULT 0, + llm_cost REAL DEFAULT 0, + tts_cost REAL DEFAULT 0, + total_llm_calls INTEGER DEFAULT 0, + total_tts_calls INTEGER DEFAULT 0, + total_tokens INTEGER DEFAULT 0, + prompt_tokens INTEGER DEFAULT 0, + completion_tokens INTEGER DEFAULT 0 +); + +CREATE TABLE IF NOT EXISTS llm_calls ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + session_id TEXT NOT NULL, + timestamp TIMESTAMP, + category TEXT, + model TEXT, + prompt_tokens INTEGER DEFAULT 0, + completion_tokens INTEGER DEFAULT 0, + cost REAL DEFAULT 0, + caller_name TEXT, + latency_ms REAL DEFAULT 0, + FOREIGN KEY (session_id) REFERENCES sessions(id) +); + +CREATE TABLE IF NOT EXISTS tts_calls ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + session_id TEXT NOT NULL, + timestamp TIMESTAMP, + provider TEXT, + voice TEXT, + char_count INTEGER DEFAULT 0, + cost REAL DEFAULT 0, + FOREIGN KEY (session_id) REFERENCES sessions(id) +); + +CREATE INDEX IF NOT EXISTS idx_llm_session ON llm_calls(session_id); +CREATE INDEX IF NOT EXISTS idx_llm_timestamp ON llm_calls(timestamp); +CREATE INDEX IF NOT EXISTS idx_llm_category ON llm_calls(category); +CREATE INDEX IF NOT EXISTS idx_llm_model ON llm_calls(model); +CREATE INDEX IF NOT EXISTS idx_tts_session ON tts_calls(session_id); +CREATE INDEX IF NOT EXISTS idx_tts_timestamp ON tts_calls(timestamp); +""" + + +def get_db(): + global _connection + if _connection is None: + _connection = sqlite3.connect(str(DB_PATH), check_same_thread=False) + _connection.row_factory = sqlite3.Row + _connection.executescript(SCHEMA) + import_json_reports() + return _connection + + +def import_json_reports(): + db = _connection + if not REPORTS_DIR.exists(): + return + existing = {row[0] for row in db.execute("SELECT id FROM sessions").fetchall()} + for f in sorted(REPORTS_DIR.glob("*.json")): + try: + data = json.loads(f.read_text()) + except (json.JSONDecodeError, OSError): + continue + session_id = data.get("session_id", f.stem) + if session_id in existing: + continue + saved_at = data.get("saved_at") + started_at = datetime.fromtimestamp(saved_at).isoformat() if saved_at else None + db.execute( + "INSERT INTO sessions (id, started_at, total_cost, llm_cost, tts_cost, total_llm_calls, total_tts_calls, total_tokens, prompt_tokens, completion_tokens) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", + (session_id, started_at, data.get("total_cost_usd", 0), data.get("llm_cost_usd", 0), data.get("tts_cost_usd", 0), data.get("total_llm_calls", 0), len(data.get("raw_tts_records", [])), data.get("total_tokens", 0), data.get("prompt_tokens", 0), data.get("completion_tokens", 0)), + ) + for rec in data.get("raw_llm_records", []): + db.execute( + "INSERT INTO llm_calls (session_id, timestamp, category, model, prompt_tokens, completion_tokens, cost, caller_name, latency_ms) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)", + (session_id, rec.get("timestamp"), rec.get("category"), rec.get("model"), rec.get("prompt_tokens", 0), rec.get("completion_tokens", 0), rec.get("cost_usd", 0), rec.get("caller_name"), rec.get("latency_ms", 0)), + ) + for rec in data.get("raw_tts_records", []): + db.execute( + "INSERT INTO tts_calls (session_id, timestamp, provider, voice, char_count, cost) VALUES (?, ?, ?, ?, ?, ?)", + (session_id, rec.get("timestamp"), rec.get("provider"), rec.get("voice"), rec.get("char_count", 0), rec.get("cost_usd", 0)), + ) + existing.add(session_id) + db.commit() + + +def record_llm_call(session_id, timestamp, category, model, prompt_tokens, completion_tokens, cost, caller_name, latency_ms): + db = get_db() + db.execute( + "INSERT INTO llm_calls (session_id, timestamp, category, model, prompt_tokens, completion_tokens, cost, caller_name, latency_ms) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)", + (session_id, timestamp, category, model, prompt_tokens, completion_tokens, cost, caller_name, latency_ms), + ) + db.commit() + + +def record_tts_call(session_id, timestamp, provider, voice, char_count, cost): + db = get_db() + db.execute( + "INSERT INTO tts_calls (session_id, timestamp, provider, voice, char_count, cost) VALUES (?, ?, ?, ?, ?, ?)", + (session_id, timestamp, provider, voice, char_count, cost), + ) + db.commit() + + +def ensure_session(session_id, started_at=None): + db = get_db() + existing = db.execute("SELECT id FROM sessions WHERE id = ?", (session_id,)).fetchone() + if not existing: + db.execute( + "INSERT INTO sessions (id, started_at) VALUES (?, ?)", + (session_id, started_at or datetime.now().isoformat()), + ) + db.commit() + + +def update_session_totals(session_id): + db = get_db() + llm = db.execute( + "SELECT COUNT(*) as calls, COALESCE(SUM(cost), 0) as cost, COALESCE(SUM(prompt_tokens), 0) as pt, COALESCE(SUM(completion_tokens), 0) as ct FROM llm_calls WHERE session_id = ?", + (session_id,), + ).fetchone() + tts = db.execute( + "SELECT COUNT(*) as calls, COALESCE(SUM(cost), 0) as cost FROM tts_calls WHERE session_id = ?", + (session_id,), + ).fetchone() + total_tokens = llm["pt"] + llm["ct"] + total_cost = llm["cost"] + tts["cost"] + db.execute( + "UPDATE sessions SET total_cost=?, llm_cost=?, tts_cost=?, total_llm_calls=?, total_tts_calls=?, total_tokens=?, prompt_tokens=?, completion_tokens=? WHERE id=?", + (total_cost, llm["cost"], tts["cost"], llm["calls"], tts["calls"], total_tokens, llm["pt"], llm["ct"], session_id), + ) + db.commit() + + +def _period_filter(period): + now = datetime.now() + if period == "today": + start = now.replace(hour=0, minute=0, second=0, microsecond=0) + elif period == "week": + start = now - timedelta(days=now.weekday()) + start = start.replace(hour=0, minute=0, second=0, microsecond=0) + elif period == "month": + start = now.replace(day=1, hour=0, minute=0, second=0, microsecond=0) + else: + return None + return start.isoformat() + + +def get_summary(period="all"): + db = get_db() + start = _period_filter(period) + if start: + where = "WHERE started_at >= ?" + params = (start,) + prev_start = _get_previous_period_start(period) + prev_where = "WHERE started_at >= ? AND started_at < ?" + prev_params = (prev_start, start) + else: + where = "" + params = () + prev_where = None + prev_params = () + + row = db.execute( + f"SELECT COUNT(*) as sessions, COALESCE(SUM(total_cost), 0) as total_cost, COALESCE(SUM(llm_cost), 0) as llm_cost, COALESCE(SUM(tts_cost), 0) as tts_cost, COALESCE(SUM(total_llm_calls), 0) as total_calls, COALESCE(SUM(total_tokens), 0) as total_tokens FROM sessions {where}", + params, + ).fetchone() + + result = { + "total_cost": round(row["total_cost"], 4), + "llm_cost": round(row["llm_cost"], 4), + "tts_cost": round(row["tts_cost"], 4), + "sessions": row["sessions"], + "total_calls": row["total_calls"], + "total_tokens": row["total_tokens"], + "avg_cost_per_session": round(row["total_cost"] / max(row["sessions"], 1), 4), + } + + if prev_where: + prev = db.execute( + f"SELECT COALESCE(SUM(total_cost), 0) as total_cost FROM sessions {prev_where}", + prev_params, + ).fetchone() + prev_cost = prev["total_cost"] + if prev_cost > 0: + result["pct_change"] = round((row["total_cost"] - prev_cost) / prev_cost * 100, 1) + else: + result["pct_change"] = None + else: + result["pct_change"] = None + + return result + + +def _get_previous_period_start(period): + now = datetime.now() + if period == "today": + return (now - timedelta(days=1)).replace(hour=0, minute=0, second=0, microsecond=0).isoformat() + elif period == "week": + start_of_week = now - timedelta(days=now.weekday()) + return (start_of_week - timedelta(days=7)).replace(hour=0, minute=0, second=0, microsecond=0).isoformat() + elif period == "month": + first_of_month = now.replace(day=1) + prev_month = first_of_month - timedelta(days=1) + return prev_month.replace(day=1, hour=0, minute=0, second=0, microsecond=0).isoformat() + return None + + +def get_timeline(period="all", group_by="session"): + db = get_db() + start = _period_filter(period) + if group_by == "day": + if start: + rows = db.execute( + "SELECT DATE(started_at) as date, SUM(llm_cost) as llm_cost, SUM(tts_cost) as tts_cost, SUM(total_cost) as total_cost, COUNT(*) as sessions FROM sessions WHERE started_at >= ? GROUP BY DATE(started_at) ORDER BY date", + (start,), + ).fetchall() + else: + rows = db.execute( + "SELECT DATE(started_at) as date, SUM(llm_cost) as llm_cost, SUM(tts_cost) as tts_cost, SUM(total_cost) as total_cost, COUNT(*) as sessions FROM sessions GROUP BY DATE(started_at) ORDER BY date" + ).fetchall() + else: + if start: + rows = db.execute( + "SELECT id, started_at, llm_cost, tts_cost, total_cost FROM sessions WHERE started_at >= ? ORDER BY started_at", + (start,), + ).fetchall() + else: + rows = db.execute( + "SELECT id, started_at, llm_cost, tts_cost, total_cost FROM sessions ORDER BY started_at" + ).fetchall() + return [dict(r) for r in rows] + + +def get_models(period="all"): + db = get_db() + start = _period_filter(period) + if start: + rows = db.execute( + "SELECT l.model, COUNT(*) as calls, COALESCE(SUM(l.cost), 0) as cost, COALESCE(SUM(l.prompt_tokens), 0) as prompt_tokens, COALESCE(SUM(l.completion_tokens), 0) as completion_tokens FROM llm_calls l JOIN sessions s ON l.session_id = s.id WHERE s.started_at >= ? GROUP BY l.model ORDER BY cost DESC", + (start,), + ).fetchall() + else: + rows = db.execute( + "SELECT model, COUNT(*) as calls, COALESCE(SUM(cost), 0) as cost, COALESCE(SUM(prompt_tokens), 0) as prompt_tokens, COALESCE(SUM(completion_tokens), 0) as completion_tokens FROM llm_calls GROUP BY model ORDER BY cost DESC" + ).fetchall() + return [dict(r) for r in rows] + + +def get_categories(period="all"): + db = get_db() + start = _period_filter(period) + if start: + rows = db.execute( + "SELECT l.category, COUNT(*) as calls, COALESCE(SUM(l.cost), 0) as cost, COALESCE(SUM(l.prompt_tokens + l.completion_tokens), 0) as tokens FROM llm_calls l JOIN sessions s ON l.session_id = s.id WHERE s.started_at >= ? GROUP BY l.category ORDER BY cost DESC", + (start,), + ).fetchall() + else: + rows = db.execute( + "SELECT category, COUNT(*) as calls, COALESCE(SUM(cost), 0) as cost, COALESCE(SUM(prompt_tokens + completion_tokens), 0) as tokens FROM llm_calls GROUP BY category ORDER BY cost DESC" + ).fetchall() + return [dict(r) for r in rows] + + +def get_sessions_list(period="all"): + db = get_db() + start = _period_filter(period) + if start: + rows = db.execute( + "SELECT id, started_at, total_cost, llm_cost, tts_cost, total_llm_calls, total_tokens FROM sessions WHERE started_at >= ? ORDER BY started_at DESC", + (start,), + ).fetchall() + else: + rows = db.execute( + "SELECT id, started_at, total_cost, llm_cost, tts_cost, total_llm_calls, total_tokens FROM sessions ORDER BY started_at DESC" + ).fetchall() + return [dict(r) for r in rows] + + +def get_session_detail(session_id): + db = get_db() + session = db.execute("SELECT * FROM sessions WHERE id = ?", (session_id,)).fetchone() + if not session: + return None + by_caller = db.execute( + "SELECT caller_name, COUNT(*) as calls, COALESCE(SUM(cost), 0) as cost, COALESCE(SUM(prompt_tokens + completion_tokens), 0) as tokens FROM llm_calls WHERE session_id = ? AND caller_name != '' GROUP BY caller_name ORDER BY cost DESC", + (session_id,), + ).fetchall() + by_model = db.execute( + "SELECT model, COUNT(*) as calls, COALESCE(SUM(cost), 0) as cost FROM llm_calls WHERE session_id = ? GROUP BY model ORDER BY cost DESC", + (session_id,), + ).fetchall() + by_category = db.execute( + "SELECT category, COUNT(*) as calls, COALESCE(SUM(cost), 0) as cost FROM llm_calls WHERE session_id = ? GROUP BY category ORDER BY cost DESC", + (session_id,), + ).fetchall() + expensive = db.execute( + "SELECT category, model, caller_name, cost, prompt_tokens, completion_tokens, latency_ms, timestamp FROM llm_calls WHERE session_id = ? ORDER BY cost DESC LIMIT 10", + (session_id,), + ).fetchall() + tts = db.execute( + "SELECT provider, COUNT(*) as calls, COALESCE(SUM(cost), 0) as cost, COALESCE(SUM(char_count), 0) as chars FROM tts_calls WHERE session_id = ? GROUP BY provider ORDER BY cost DESC", + (session_id,), + ).fetchall() + return { + "session": dict(session), + "by_caller": [dict(r) for r in by_caller], + "by_model": [dict(r) for r in by_model], + "by_category": [dict(r) for r in by_category], + "expensive_calls": [dict(r) for r in expensive], + "tts_by_provider": [dict(r) for r in tts], + } + + +def get_expensive_calls(period="all", limit=10): + db = get_db() + start = _period_filter(period) + if start: + rows = db.execute( + "SELECT l.category, l.model, l.caller_name, l.cost, l.prompt_tokens, l.completion_tokens, l.latency_ms, l.timestamp, l.session_id FROM llm_calls l JOIN sessions s ON l.session_id = s.id WHERE s.started_at >= ? ORDER BY l.cost DESC LIMIT ?", + (start, limit), + ).fetchall() + else: + rows = db.execute( + "SELECT category, model, caller_name, cost, prompt_tokens, completion_tokens, latency_ms, timestamp, session_id FROM llm_calls ORDER BY cost DESC LIMIT ?", + (limit,), + ).fetchall() + return [dict(r) for r in rows] +``` + +**Step 2: Verify the module loads** + +Run: `cd /Users/lukemacneil/code/ai-podcast && python -c "from backend.services.cost_db import get_db; db = get_db(); print('OK, sessions:', db.execute('SELECT COUNT(*) FROM sessions').fetchone()[0])"` + +Expected: `OK, sessions: 18` (or however many JSON reports exist) + +**Step 3: Commit** + +```bash +git add backend/services/cost_db.py +git commit -m "Add SQLite cost database module with JSON import" +``` + +--- + +### Task 2: Integrate SQLite Writes into Cost Tracker + +**Files:** +- Modify: `backend/services/cost_tracker.py` + +**Step 1: Add dual-write to `record_llm_call`** + +At the top of `cost_tracker.py`, add the import: +```python +from backend.services import cost_db +``` + +In `record_llm_call()` (around line 148, after appending to `self.llm_records`), add: +```python +try: + cost_db.ensure_session(self._session_id) + cost_db.record_llm_call( + self._session_id, record.timestamp, record.category, record.model, + record.prompt_tokens, record.completion_tokens, record.cost_usd, + record.caller_name, record.latency_ms, + ) +except Exception: + pass # don't break show over analytics +``` + +**Step 2: Add dual-write to `record_tts_call`** + +In `record_tts_call()` (around line 166, after appending to `self.tts_records`), add: +```python +try: + cost_db.record_tts_call( + self._session_id, record.timestamp, record.provider, record.voice, + record.char_count, record.cost_usd, + ) +except Exception: + pass +``` + +**Step 3: Add session_id tracking to `__init__`** + +Add `self._session_id` to the constructor. Generate it from timestamp: +```python +self._session_id = f"session-{datetime.now().strftime('%Y-%m-%d_%H%M%S')}" +``` + +**Step 4: Update session totals on `save()`** + +In the `save()` method, after writing the JSON file, add: +```python +try: + cost_db.update_session_totals(self._session_id) +except Exception: + pass +``` + +**Step 5: Commit** + +```bash +git add backend/services/cost_tracker.py +git commit -m "Dual-write cost records to SQLite" +``` + +--- + +### Task 3: API Endpoints + +**Files:** +- Modify: `backend/main.py` (add routes near existing `/api/costs` endpoints around line 10299) + +**Step 1: Add new cost dashboard endpoints** + +Add these routes near the existing cost endpoints (around line 10308): + +```python +from backend.services import cost_db + +@app.get("/api/costs/summary") +async def get_cost_summary(period: str = "all"): + return cost_db.get_summary(period) + +@app.get("/api/costs/timeline") +async def get_cost_timeline(period: str = "all", group_by: str = "session"): + return cost_db.get_timeline(period, group_by) + +@app.get("/api/costs/models") +async def get_cost_models(period: str = "all"): + return cost_db.get_models(period) + +@app.get("/api/costs/categories") +async def get_cost_categories(period: str = "all"): + return cost_db.get_categories(period) + +@app.get("/api/costs/sessions") +async def get_cost_sessions(period: str = "all"): + return cost_db.get_sessions_list(period) + +@app.get("/api/costs/session/{session_id}") +async def get_cost_session_detail(session_id: str): + detail = cost_db.get_session_detail(session_id) + if not detail: + from fastapi.responses import JSONResponse + return JSONResponse(status_code=404, content={"error": "Session not found"}) + return detail + +@app.get("/api/costs/expensive") +async def get_expensive_calls(period: str = "all", limit: int = 10): + return cost_db.get_expensive_calls(period, limit) +``` + +**Step 2: Add route to serve the costs page** + +Near the existing root route (around line 7654), add: + +```python +@app.get("/costs") +async def costs_page(): + return FileResponse(frontend_dir / "costs.html") +``` + +**Step 3: Verify endpoints respond** + +Run the server: `python -m uvicorn backend.main:app --reload --reload-dir backend --host 0.0.0.0 --port 8000` + +Test: `curl -s http://localhost:8000/api/costs/summary?period=all | python -m json.tool` + +Expected: JSON with total_cost, llm_cost, tts_cost, sessions, etc. + +**Step 4: Commit** + +```bash +git add backend/main.py +git commit -m "Add cost dashboard API endpoints" +``` + +--- + +### Task 4: Dashboard HTML + +**Files:** +- Create: `frontend/costs.html` + +**Step 1: Create the dashboard page** + +Create `frontend/costs.html` — standalone HTML page with: +- Chart.js from CDN (`https://cdn.jsdelivr.net/npm/chart.js`) +- Link to `css/style.css` (shared theme) and `css/costs.css` (dashboard-specific) +- Script tag for `js/costs.js` +- Structure: header with time range tabs, 4 summary cards, 4 chart containers, 2 tables +- Use the same CSS variables as the control panel (`--bg`, `--bg-light`, `--accent`, `--text`, etc.) + +Layout structure: +```html + + + + + + Cost Dashboard - Luke at the Roost + + + + + +
+

Cost Dashboard

+ Back to Show + +
+
+
+
+
Total Spend
+
--
+
+
+
+
LLM / TTS
+
--
+
+
+
Sessions
+
--
+
+
+
Avg / Session
+
--
+
+
+
+
+

Cost Over Time

+ +
+
+

Cost by Model

+ +
+
+
+
+

Cost by Category

+ +
+
+

Cost Per Session

+ +
+
+
+
+

Most Expensive Calls

+ + + + + +
ModelCategoryCallerTokensCostLatency
+
+
+

Sessions

+ + + + + +
DateLLMTTSTotalCalls
+
+
+ +
+ + + +``` + +**Step 2: Commit** + +```bash +git add frontend/costs.html +git commit -m "Add cost dashboard HTML page" +``` + +--- + +### Task 5: Dashboard CSS + +**Files:** +- Create: `frontend/css/costs.css` + +**Step 1: Create dashboard-specific styles** + +Create `frontend/css/costs.css` using the existing CSS variables from `style.css`. Key styles: +- `.costs-header` — flex row with title, back link, and period tabs +- `.period-tabs` / `.period-tab` — tab buttons, active state uses `--accent` +- `.summary-cards` — 4-column grid +- `.card` — `background: var(--bg-light)`, border, rounded corners matching `--radius` +- `.card-value` — large font, `color: var(--text)` +- `.card-change` — small text, green for negative (saving), red for positive (increase) +- `.chart-row` — 2-column grid +- `.chart-container` — padded card with canvas +- `.table-container` — styled tables matching dark theme +- `.session-detail` — full-width detail view +- Responsive: single column below 768px + +Use `var(--bg)`, `var(--bg-light)`, `var(--accent)`, `var(--text)`, `var(--text-muted)`, `var(--radius)`, `var(--radius-sm)`, `var(--transition)` throughout. + +**Step 2: Commit** + +```bash +git add frontend/css/costs.css +git commit -m "Add cost dashboard CSS" +``` + +--- + +### Task 6: Dashboard JavaScript + +**Files:** +- Create: `frontend/js/costs.js` + +**Step 1: Create the dashboard JS** + +Create `frontend/js/costs.js` with: + +**State:** +```javascript +let currentPeriod = 'all'; +let charts = {}; // store Chart.js instances for destroy/recreate +``` + +**Init:** +```javascript +document.addEventListener('DOMContentLoaded', () => { + document.querySelectorAll('.period-tab').forEach(tab => { + tab.addEventListener('click', () => { + document.querySelector('.period-tab.active').classList.remove('active'); + tab.classList.add('active'); + currentPeriod = tab.dataset.period; + loadDashboard(); + }); + }); + document.getElementById('close-detail').addEventListener('click', closeDetail); + loadDashboard(); +}); +``` + +**Data loading — `loadDashboard()`:** +- Fetch all endpoints in parallel: summary, timeline, models, categories, sessions, expensive +- Call render functions for each section + +**Render functions:** +- `renderSummary(data)` — populate the 4 summary cards, format as `$X.XX`, show % change with color +- `renderTimeline(data)` — Chart.js line chart with LLM and TTS as separate datasets, `--accent` and `--devon` colors +- `renderModels(data)` — Chart.js doughnut chart with model name labels +- `renderCategories(data)` — Chart.js horizontal bar chart +- `renderSessionBars(data)` — Chart.js bar chart, bars colored based on above/below average +- `renderExpensiveTable(data)` — populate table rows +- `renderSessionsTable(data)` — populate table rows with click handler to show detail +- `showSessionDetail(sessionId)` — fetch `/api/costs/session/{id}`, show detail section, populate tables +- `closeDetail()` — hide detail section + +**Chart.js config notes:** +- Use dark theme: grid lines `rgba(245, 240, 229, 0.1)` (--text at 10%), tick color `var(--text-muted)` +- Chart colors palette: `#e8791d` (accent), `#c4944a` (devon), `#5a8a3c` (green), `#cc2222` (red), `#4a8ac4` (blue), `#8a5ac4` (purple), `#c4845a` (tan) +- Tooltips: dark background, light text +- Destroy existing chart instance before creating new one (prevents memory leaks on period switch) + +**Utility:** +- `formatCost(n)` — returns `$X.XX` or `$X.XXXX` for small amounts +- `formatDate(iso)` — returns readable date +- `shortenModel(name)` — strip provider prefix from model names for chart labels + +**Step 2: Commit** + +```bash +git add frontend/js/costs.js +git commit -m "Add cost dashboard JavaScript with Chart.js" +``` + +--- + +### Task 7: Integration Test + +**Step 1: Manual verification checklist** + +Start the server and navigate to `http://localhost:8000/costs`: + +1. Page loads with dark theme, no console errors +2. All Time tab is active by default, shows all 18 sessions +3. Summary cards show total spend, LLM/TTS split, session count, avg cost +4. Cost Over Time line chart renders with data points +5. Cost by Model doughnut shows model breakdown +6. Cost by Category bar chart shows category breakdown +7. Cost Per Session bars render with above/below-average coloring +8. Most Expensive Calls table populated +9. Sessions table populated, rows clickable +10. Click a session row → detail view shows with per-caller, per-model, per-category tables +11. Click "Back" → returns to main dashboard +12. Switch to "This Week" tab → all charts update (may show fewer/no data) +13. Switch to "This Month" → charts update with March data +14. Switch back to "All Time" → full data restored + +**Step 2: Commit all remaining changes** + +```bash +git add -A +git commit -m "Cost dashboard complete — SQLite backend, Chart.js frontend" +``` + +--- + +## File Summary + +| Action | File | +|--------|------| +| Create | `backend/services/cost_db.py` | +| Modify | `backend/services/cost_tracker.py` | +| Modify | `backend/main.py` | +| Create | `frontend/costs.html` | +| Create | `frontend/css/costs.css` | +| Create | `frontend/js/costs.js` | + +## Dependencies + +- Chart.js loaded from CDN (no npm install needed) +- SQLite is stdlib (no pip install needed) +- No new Python packages required diff --git a/docs/plans/2026-05-31-alpine-relocation-design.md b/docs/plans/2026-05-31-alpine-relocation-design.md new file mode 100644 index 0000000..b4a6d83 --- /dev/null +++ b/docs/plans/2026-05-31-alpine-relocation-design.md @@ -0,0 +1,78 @@ +# Relocate the Show to Alpine, TX / Big Bend + +**Date:** 2026-05-31 +**Status:** Approved, implementing + +## Goal + +Luke moved to Alpine, Texas. Move the show's world from southern New Mexico +(Deming/Lordsburg) to the Big Bend region of far West Texas. Callers should come +from and be familiar with Alpine, Marfa, Marathon, Terlingua, Fort Stockton, and +the Big Bend area. Devon moves with the show. Silas gets an arc beat that +relocates The Wellspring to Terlingua. + +## Changes + +### 1. Caller generation — `backend/services/caller_gen.py` + +- `BATCH_SYSTEM_PROMPT` opener: "…radio show in New Mexico" → "…in Alpine, Texas, + in the Big Bend country of far West Texas." +- Add a **geographic knowledge block** (real, accurate facts) so callers ground + themselves in real places instead of generic desert. Towns: + - **Alpine** — hub (~6k), Brewster County seat, Sul Ross State University, + mile-high ranching/railroad town, small arts scene. + - **Marfa** — minimalist-art tourist town (Chinati/Donald Judd, Prada Marfa), + the Marfa Lights, old ranching families vs. hipster influx. + - **Marathon** — tiny, the Gage Hotel, east gateway to Big Bend NP. + - **Terlingua** — quicksilver-mining ghost town, famous chili cookoff, + river-rafting outfitters, off-grid desert eccentrics, the Starlight Theatre, + near the Rio Grande / Mexico border. + - **Fort Stockton** — oilfield/I-10 town to the north, Pecos County, Paisano + Pete, working-class. + - **Big Bend** — Chisos Mountains, Rio Grande, dark skies (McDonald Observatory + near Fort Davis), remote, border proximity, Permian Basin oil money north. + - Rule: only reference real places/facts; don't invent businesses or landmarks. + +### 2. Whisper prompt — `backend/services/transcription.py` + +Update locale and seed proper nouns: "…a late-night radio talk show in Alpine, +Texas, in the Big Bend region. Callers reference Alpine, Marfa, Marathon, +Terlingua, Fort Stockton, and Big Bend." + +### 3. Devon — `backend/services/intern.py` + +Moved with the show. Keep "Communications degree from NMSU" (alma mater); +"You live in a studio in Deming" → "studio in Alpine." + +### 4. Silas — relocate The Wellspring to Terlingua + +- `~/code/dotfiles/silas/silas.md`: identity location Deming → Terlingua badlands; + update `arc_state` frontmatter to the relocation; add an Arc Log entry + (2026-05-31) — post-reckoning fresh start, moving the commune to desert outside + Terlingua, the move straining the forty members. +- `data/regulars.json`: update Silas's `job`, `location`, and the + `stable_seeds.style` "commune outside Deming" → Terlingua. Leave the 6 past + `call_history` summaries untouched — they happened in Deming; the move is the + new development. + +### 5. Weather/town-news enrichment — `backend/main.py` (now a real feature) + +The block in `enrich_caller_background()` called `_get_town_from_location` / +`_get_weather_for_town`, which never existed — silently NameError-ing. Implement: + +- `BIG_BEND_TOWNS`: dict of town → (lat, lon) for Alpine, Marfa, Marathon, + Terlingua, Fort Stockton, Big Bend (Chisos Basin), Fort Davis, Presidio. +- `_get_town_from_location(text)`: scan lowercased text for a known town, + return canonical key (handles "ft stockton"/"fort stockton"). +- `_get_weather_for_town(town)`: Open-Meteo current weather (free, no key), + WMO weather_code → phrase, returns e.g. "58°F, clear skies". +- Update town-news query: NM/AZ branch → `f"{town.title()} Texas"`. +- Wire session base_ctx `weather` (was hardcoded "cool desert night") to live + Alpine weather, graceful fallback on failure. + +All network calls degrade gracefully (existing `asyncio.timeout` + try/except). + +## Out of scope / left as-is + +- Past `call_history` summaries (genuinely happened in Deming). +- `main.py:3124` state-abbreviation map (generic, not show-locale). diff --git a/docs/plans/2026-06-02-caller-variety-and-devon-search-design.md b/docs/plans/2026-06-02-caller-variety-and-devon-search-design.md new file mode 100644 index 0000000..b6089c9 --- /dev/null +++ b/docs/plans/2026-06-02-caller-variety-and-devon-search-design.md @@ -0,0 +1,56 @@ +# Caller Variety, Movable Callers, and Devon Search Fix + +**Date:** 2026-06-02 +**Status:** Approved, implementing + +## Problems + +1. **Callers feel formulaic** — too many deep moral dilemmas; the roster prompt + *enforces* it ("at least half moral dilemmas" + "NEVER generate callers who + are just enthusiastic about a hobby"). +2. **Callers circle forever** — they don't take advice, restating the same moral + issue until the host cuts them off. The live dialog prompt gives a `situation` + + `secret_want` but no mechanic to be moved, persuaded, or reach resolution. +3. **Devon's search fails** — SearXNG at `localhost:8888` is unreachable whenever + the laptop's Docker Desktop isn't running. Fragile. + +## Changes + +### A. Roster variety — `backend/services/caller_gen.py` (`BATCH_SYSTEM_PROMPT`) + +- Remove the absolute ban on hobby/job/story callers. +- Replace "at least half moral dilemmas" with an explicit distribution for a + 10-caller roster (dilemmas still lead): + - **4–5** moral dilemmas / confessions / betrayals — keep the STAKES language. + - **2–3** storytellers & enthusiasts — a wild thing that happened, a fascinating + niche obsession or fact, a vivid slice-of-life. No deep dilemma required. + - **1–2** believers / chaos — earnest UFO/cryptid/conspiracy callers + (Coast-to-Coast sincerity) or a big eccentric personality on a rant. +- Keep the anti-collision rule, "reason they HAD to call tonight," and + "even lighter callers need energy and specificity." + +### B. Movable callers — `backend/main.py` (`get_caller_prompt`) + +Add a concise conversational-arc block for every caller: +- You have a position/want, but you're a real person — if Luke makes a good + point, genuinely react: agree, change your mind, soften, dig in, or decide. +- Don't restate a point/dilemma you've already made; the conversation must move. + You can reach a resolution, a decision, or an emotional turn. You are not + required to stay stuck. + +Stacks on the existing "don't restate facts / move the story forward" rule. +Must keep `get_caller_prompt` output under the 3500-char test cap. + +### C. SearXNG → NAS — `backend/config.py`, `backend/services/news.py` + +- Deploy SearXNG to **mmgnas** as an always-on container (deploy-nas-docker). +- Add `searxng_url` to `config.py` (env-overridable), default to the NAS URL. +- `news.py` reads `settings.searxng_url` instead of the hardcoded constant; + `intern.py` imports `SEARXNG_URL` from `news.py`, so Devon, headlines, and + caller news-grounding all follow. + +## Verification + +- Run test suite (note: 2 pre-existing stale `test_caller_gen.py` failures). +- Live caller-gen batch → review the roster mix. +- Devon end-to-end: a `web_search` against the NAS SearXNG returns real results. diff --git a/press_release.md b/press_release.md new file mode 100644 index 0000000..a1cb317 --- /dev/null +++ b/press_release.md @@ -0,0 +1,55 @@ +# Press Release + +**FOR IMMEDIATE RELEASE** + +## New Podcast "Luke at the Roost" Blends AI-Generated Callers with Live Radio Format, Creating a One-of-a-Kind Late-Night Show + +*Every caller is a unique AI character with a full backstory, personality, and speaking style — and real listeners can call in too* + +**Lordsburg, NM — February 27, 2026** — "Luke at the Roost," a late-night call-in talk show hosted by Luke MacNeil, is redefining what a podcast can be by combining real-time AI-generated callers with traditional live radio. Now 23 episodes in, the show has built a loyal following with its unpredictable conversations, genuine emotional depth, and a cast of characters that listeners have come to know by name. + +### A New Kind of Call-In Show + +Unlike traditional podcasts that rely on scripted segments or pre-recorded interviews, Luke at the Roost generates every AI caller in real time. Each one arrives with a complete identity — name, age, job, hometown, speaking style, and a specific reason for calling. Some are nervous first-timers. Others are regulars who remember past conversations and reference previous episodes. The result is a show that feels like tuning into a real late-night radio station in the American Southwest. + +"The whole point is that these conversations feel real," said MacNeil. "The AI doesn't read from a script. Neither do I. We're just two people talking, and sometimes it goes somewhere neither of us expected." + +### Real Callers Welcome + +The show isn't AI-only. Real listeners can call in live at **208-439-LUKE (208-439-5853)** or email submissions@lukeattheroost.com. The mix of AI-generated and human callers creates an atmosphere where the line between the two becomes part of the fun. + +### Built from Scratch + +The entire technical infrastructure — from the AI caller generator with over 1,000 unique calling reasons, to the multi-track recording system, voice synthesis pipeline, and automated post-production — was built custom by MacNeil. Episodes go through professional-grade audio processing including compression, music ducking, stereo mixing, and broadcast-standard loudness normalization before being automatically published to all major podcast platforms. + +### Where to Listen + +Luke at the Roost is available on all major podcast platforms: + +- **Website**: https://lukeattheroost.com +- **Spotify**: https://open.spotify.com/show/0ZrpMigG1fo0CCN7F4YmuF +- **Apple Podcasts**: https://podcasts.apple.com/us/podcast/luke-at-the-roost/id1875205848 +- **YouTube**: https://www.youtube.com/watch?v=xryGLifMBTY&list=PLGq4uZyNV1yYH_rcitTTPVysPbC6-7pe- +- **Discord**: https://discord.gg/5CnQZxDM + +### About MacNeil Media Group + +MacNeil Media Group is an independent media company focused on experimental audio and AI-driven content. Luke at the Roost is its flagship production. + +### Media Contact + +Luke MacNeil +luke@lukeattheroost.com +https://lukeattheroost.com + +--- + +### Summary (for submission forms) + +**Headline**: New Podcast "Luke at the Roost" Blends AI-Generated Callers with Live Radio Format + +**Summary (short)**: Luke at the Roost is a late-night call-in talk show where every caller is a unique AI-generated character with a full backstory and personality. Real listeners can call in too. 23 episodes in, the show has built a following with its unpredictable conversations and genuine emotional depth. + +**Category**: Entertainment / Technology / Podcasting + +**Tags**: podcast, AI, artificial intelligence, late-night radio, call-in show, talk show, entertainment technology, indie podcast, New Mexico