Overview

Chapter 2: The Executive Producer & Curriculum Agent: Song Selection & Phonics

Playbook: PB-03 (Autonomous Agentic Video Studio: Kids Karaoke & Educational Songs)
Tooling Focus: Gemini 2.5 Pro (Curriculum Logic), Gemini 2.5 Flash (Budget Triage), Python 3.11+
Quality Standard: 7 Universal Quality Acceptance Gates with Hands-On Lab & Tested Solution
Target Audience: Year 1 Computer Science & Software Engineering Students

0. The Big Picture: Hit Pop Songs vs. Boring Textbooks

Why do you still remember nursery rhymes and pop song lyrics from a decade ago without ever studying them, while forgetting a paragraph from a history textbook after 5 minutes?

• The human brain is a natural rhythm machine!
• When words are delivered as continuous flat speech, young toddlers hear an unbroken wall of confusing sounds.
• But when speech is locked to a 108 BPM musical meter, the beat acts like a musical metronome that chops words into predictable, catchy rhythmic slots (scientists call this Prosodic Bootstrapping).

In this chapter, you will build the Executive Producer & Curriculum Agent: an autonomous AI system that selects classic songs, crafts strictly-metered 60-second lyrics (6 to 8 syllables per line), and enforces a strict $3.50 per-episode budget guardrail before calling expensive rendering APIs.

0.1 Engineering Jargon Demystifier Table

0.2 The 5-Minute Micro-Lab: The Syllable & Budget Pre-Flight Linter

Run this zero-dependency Python script to see how automated software audits song lyrics for syllable meter and checks the episode budget cap:

"""
Micro-Lab: Syllable Meter & Budget Linter
PB-03 Chapter 2 Micro-Lab (Zero External Dependencies)
"""
import re

def count_syllables_approx(word: str) -> int:
    w = word.lower()
    vowels = "aeiouy"
    count = len(re.findall(r"[aeiouy]+", w))
    if w.endswith("e") and not w.endswith("le") and count > 1:
        count -= 1
    return max(1, count)

def lint_song_curriculum(lines: list, estimated_cost_usd: float, budget_cap_usd: float = 3.50) -> dict:
    meter_errors = []
    for idx, line in enumerate(lines, 1):
        words = line.split()
        total_syl = sum(count_syllables_approx(w) for w in words)
        if not (5 <= total_syl <= 9):
            meter_errors.append(f"Line {idx} has {total_syl} syllables (Allowed 5-9): '{line}'")
            
    budget_ok = estimated_cost_usd <= budget_cap_usd
    passed = (len(meter_errors) == 0) and budget_ok
    return {
        "meter_errors": meter_errors,
        "estimated_cost": f"${estimated_cost_usd:.2f}",
        "budget_cap": f"${budget_cap_usd:.2f}",
        "verdict": "[PASS]" if passed else "[FAIL]"
    }

if __name__ == "__main__":
    test_lyrics = [
        "The cow on the farm says moo",
        "The duck on the pond says quack",
        "The sheep on the hill says baa"
    ]
    res = lint_song_curriculum(test_lyrics, estimated_cost_usd=3.02)
    print("Song Curriculum Audit Report:")
    print(f"  Meter Errors:   {res['meter_errors']}")
    print(f"  Cost Check:     {res['estimated_cost']} <= {res['budget_cap']}")
    print(f"  Curriculum Status: {res['verdict']}")
    assert res["verdict"] == "[PASS]"
    print("[PASS] Micro-lab assertions verified successfully.")

0.3 Freshman Survival Guide: 3 Traps to Avoid

1. Trap 1: The Long Song Trap: Letting the agent write a 4-minute song with 10 verses. Toddlers lose interest after 60 seconds and your video rendering bill will exceed $15. Keep every episode to exactly 60 seconds.
2. Trap 2: Syllable Tripping: Writing lines with 15 syllables followed by 3 syllables. The synthetic singer will stumble over the words. Enforce 6 to 8 syllables per line.
3. Trap 3: Abstract Adult Words: Using adult vocabulary like "magnificent dairy cow". Toddlers only understand simple concrete words: "Look! A big cow!".

1. Zero-Fluff & Pedagogical Song Engineering Rigor

In early childhood language acquisition (ages 2–5), music is the premier cognitive vehicle for vocabulary ingestion. The human brain parses melodic contours before it acquires syntax.

Under the Prosodic Bootstrapping Hypothesis (Gleitman & Wanner), young children exploit the exaggerated pitch inflections, metric regularity, and repetitive syllable pulses of music to locate word boundaries in continuous auditory streams. When a toddler listens to spoken language, the speech stream sounds like an unbroken wall of phonemes. When that same language is structured as a 108 BPM nursery song, the musical meter divides the speech stream into predictable, discrete rhythmic slots:

PROSODIC BOOTSTRAPPING THROUGH 108 BPM NURSERY METER:
┌────────────────────────────────────────────────────────────────────────┐
│ UNCONSTRAINED SPOKEN STREAM:                                           │
│ "thecowonthefarmsaysmoomoomooandtheduckonthefarmsaysquackquackquack"    │
│ ──► Result: Syllable boundaries blur; toddler working memory overloaded│
├────────────────────────────────────────────────────────────────────────┤
│ 108 BPM 4/4 NURSERY SONG GRID (2 Bars = 8 Beats = 8 Syllables):        │
│ Beat 1: The  | Beat 2: Cow  | Beat 3: on   | Beat 4: the               │
│ Beat 5: farm | Beat 6: says | Beat 7: MOO! | Beat 8: [Rest]            │
│ ──► Result: Target word "Cow" lands on strong downbeat (Beat 2);       │
│     Target onomatopoeia "MOO!" lands on accented syncopation (Beat 7). │
└────────────────────────────────────────────────────────────────────────┘

The Executive Producer's Budgeting & Resource Bounds

In an autonomous production company, creative ambitions must be strictly bound by unit economics. If the Curriculum Agent designs a 5-minute song with 12 verses, the studio's downstream render budget will explode:

• 5 minutes = 60 Veo 2 video clips $\times $0.22 = $13.20$ (violating the studio's $$3.50$ per-episode budget cap).
• High-duration videos suffer severe toddler attention drop-off (average completion rate for a 5-minute video among 3-year-olds is $< 18%$, whereas 60-second micro-learning songs achieve $> 82%$ completion on YouTube Kids).

Therefore, the Executive Producer Agent enforces the 60-Second Micro-Curriculum Law:

1. Total Duration: Exactly $60.0\text{ seconds}$ ($\pm 0.5\text{s}$).
2. Target Vocabulary Density: Exactly 3 core target words per episode (e.g., Cow, Duck, Sheep or Red, Blue, Yellow).
3. Syllable Meter Constraint: Exactly 6 to 8 syllables per musical phrase, guaranteeing clean alignment with 2 musical bars in 4/4 time at 108 BPM.
4. Chorus Repetition Factor: Key chorus motifs must repeat at least 3 times to achieve permanent memory encoding.

2. Naive vs. Production Contrasts in Song Curriculum Design

Contrast Breakdown: Lyric Architecture

The Naive Failure Lyrics (Unmetered)

Old MacDonald had a big farm with a lot of wonderful animals on it,
And on that farm he had a magnificent Holstein dairy cow that gave milk,
With a moo moo here and a moo moo there, everywhere moo moo!

Why this fails:

• Line 1 has 17 syllables; Line 2 has 22 syllables. It is physically impossible to sing these lines to a nursery melody at 108 BPM without incomprehensible auctioneer-speed slurring.
• Contains advanced adult vocabulary ("magnificent", "Holstein", "dairy"), completely violating CEFR Pre-A1 constraints.

The Production Curriculum Lyrics (Metered & Calibrated)

Old Mac-Don-ald had a farm, (7 syllables | 2 bars @ 108 BPM)
E - I - E - I - O!          (5 syllables | 2 bars with rests)
And on that farm he had a COW, (8 syllables | 2 bars)
With a MOO-MOO here!        (5 syllables | 2 bars)

Why this succeeds:

• Every syllable fits into a musical quarter note or eighth note slot.
• Target noun (COW) and sound (MOO) land on accented melodic peaks.

3. Latest Google Model Configurations & Curriculum Prompts

The Curriculum Agent leverages Gemini 2.5 Pro (gemini-2.5-pro) for high-depth poetic meter reasoning and phoneme analysis, while the Executive Producer uses Gemini 2.5 Flash (gemini-2.5-flash) for rapid budget triage:

┌────────────────────────────────────────────────────────────────────────┐
│                   CURRICULUM REASONING & BUDGET PIPELINE               │
├────────────────────────────────────────────────────────────────────────┤
│ 1. EXECUTIVE PRODUCER (Gemini 2.5 Flash)                               │
│    - Selects Theme from Master Curriculum Backlog                      │
│    - Allocates Token Budget: 4,000 Flash tokens, 2,000 Pro tokens      │
│    - Sets Cost Ceiling: $3.50                                          │
│                               ▼                                        │
│ 2. CURRICULUM AGENT (Gemini 2.5 Pro)                                   │
│    - Ingests CEFR Pre-A1 Lexicon & Phonetic Targets                    │
│    - Solves metric constraints (6-8 syllables per line)                │
│    - Emits Structured Episode Curriculum JSON                          │
│                               ▼                                        │
│ 3. BUDGET LINTER (Python Engine)                                       │
│    - Pre-flight asserts total cost <= $3.50                            │
│    - Commits manifest to Studio Blackboard                             │
└────────────────────────────────────────────────────────────────────────┘

Production Curriculum System Prompt (Gemini 2.5 Pro)

You are the Lead Curriculum & Educational Songwriter Agent for an AI Children's Media Studio.
Your mission is to write 60-second educational sing-along song lyrics for toddlers (ages 2-5, CEFR Pre-A1).

MANDATORY RULES:
1. Tempo Anchor: 108 BPM (4/4 time signature). 1 Bar = 4 Beats = ~2.22 seconds.
2. Structure: 
   - Intro (8.0s): Welcome & song hook
   - Verse 1 (14.0s): Word 1 (Encounter -> Phonics -> Call & Response)
   - Verse 2 (14.0s): Word 2
   - Verse 3 (14.0s): Word 3
   - Outro (10.0s): Celebratory chorus & goodbye
   Total = Exactly 60.0 seconds.
3. Syllable Constraint: Every sung line MUST contain between 6 and 8 syllables.
4. Vocabulary: Strictly CEFR Pre-A1. Use repetitive phonetic onomatopoeia.
5. Output format: Valid JSON adhering to EpisodeCurriculumSchema.

4. Quantitative Trade-Off Matrix

Recommendation: Archetype A & B (Cumulative Rhymes and Action Songs) provide the highest toddler sing-along success and phonemic retention while maintaining predictable token generation costs.

5. The 10 Operational Failure Modes in Song Curriculum Design

┌────────────────────────────────────────────────────────────────────────┐
│             THE 10 OPERATIONAL FAILURE MODES IN SONG CURRICULA         │
├────────────────────────────────────────────────────────────────────────┤
│  1. Polysyllabic Lexical Overload      6. Insufficient Repetition Gate │
│  2. Metric Clashing (Syncopation Trip) 7. Idiomatic Ambiguity for ESL  │
│  3. Phantom / False Rhymes             8. Vocal Pitch Register Strain  │
│  4. Thematic Drift Across Verses       9. Verse-Chorus Asymmetry       │
│  5. Syllable Cramming (> 9 / bar)     10. Runaway Generation Tokens    │
└────────────────────────────────────────────────────────────────────────┘

1. Polysyllabic Lexical Overload:
   • Root Cause: LLM defaults to sophisticated adult adjectives ("magnificent", "delicious", "extraordinary").
   • Detection: Flesch-Kincaid grade level $> 1.0$; words with $> 2$ syllables.
   • Remediation: Restrict vocabulary to CEFR Pre-A1 list; hard filter rejecting any word $> 2$ syllables except basic compounds ("sunshine").
2. Metric Clashing (Syncopation Tripping):
   • Root Cause: Generating 11 syllables in a 4-beat bar, forcing the singer to rush syllables.
   • Detection: Syllables-per-second ratio $> 3.5\text{ syl/s}$.
   • Remediation: Enforce strict syllable count: 6 to 8 syllables per 2-bar line.
3. Phantom / False Rhymes:
   • Root Cause: LLMs confusing orthographic spelling with phonetic rhyming (e.g., pairing "cow" with "low", or "bear" with "hear").
   • Detection: Comparing CMU Pronouncing Dictionary phoneme endings.
   • Remediation: Curriculum agent must verify exact rhyme endings via IPA phonetic anchors.
4. Thematic Drift Across Verses:
   • Root Cause: Unconstrained generation introducing unrelated topics (e.g., Verse 1: Cow, Verse 2: Helicopter, Verse 3: Pizza).
   • Detection: Vocabulary semantic distance variance $> 0.4$.
   • Remediation: Topic taxonomy lock: all 3 target words must belong to the identical category ontology.
5. Syllable Cramming (> 9 Syllables per Bar):
   • Root Cause: Trying to express complex narrative thoughts in a single line.
   • Remediation: Programmatic linter splits or trims any phrase exceeding 8 syllables.
6. Insufficient Repetition Gate:
   • Root Cause: Target vocabulary word spoken only once in the entire song.
   • Detection: Word frequency count in lyrics $< 3$.
   • Remediation: Curriculum rule: Target word must appear at least 3 times in its designated verse.
7. Idiomatic Ambiguity for ESL Learners:
   • Root Cause: Using colloquial cultural idioms (e.g., "raining cats and dogs" or "hit the road").
   • Detection: Figurative language detection prompt.
   • Remediation: Strictly literal, concrete physical nouns and onomatopoeia.
8. Vocal Pitch Register Strain:
   • Root Cause: Melodic notes leaping more than an octave, exceeding child vocal comfort zones.
   • Remediation: Limit vocal range to the 5-note pentatonic scale (C4 to G4).
9. Verse-Chorus Asymmetry:
   • Root Cause: Verses taking 52 seconds, leaving only 8 seconds for the outro dance.
   • Remediation: Rigid mathematical template: Intro (8s), 3 Verses (14s each), Outro (10s).
10. Runaway Generation Tokens:
    • Root Cause: Missing max_output_tokens or unbounded response schemas causing LLM to generate 15 verses.
    • Remediation: Set max_output_tokens: 1200 and use strict JSON schema response modes.

6. Hands-On Lab: Autonomous Song Syllabus & Token Budget Planner

🎯 Lab Objective

Build and test CurriculumPlannerEngine—the autonomous subsystem for the Executive Producer and Curriculum Specialist agents. It selects a theme, drafts metered sing-along song lyrics satisfying CEFR Pre-A1 constraints, verifies syllable counts per musical bar, and calculates comprehensive Google GenAI API cost budgets to guarantee the episode remains under the $$3.50$ ceiling.

📋 Scenario & Production Requirements

1. Curriculum Specification:
   • Theme: Farm Animals
   • Target Words: Cow, Duck, Sheep
   • Episode Duration: Exactly 60.0 seconds.
   • Target Tempo: 108 BPM (4/4 time signature).
2. Lyric & Syllable Constraints:
   • 3 Verses (one per animal).
   • Every sung line must have exactly 6 to 8 syllables.
   • Target word must appear at least 3 times per verse.
3. Executive Producer Budget Model:
   • Calculate Gemini 2.5 Flash & Pro token costs.
   • Factor in Imagen 3 keyframes (12 images @ $0.04), Veo 2 video (11 clips @ $0.22), Cloud TTS audio, and Lyria music.
   • Assert total estimated cost $\le $3.50$.
4. Automated Verification:
   • Assert that 100% of lyric lines pass the 6–8 syllable constraint.
   • Assert exact 60.0s duration.
   • Assert budget compliance.

7. Recommended Answer & Executable Verification Script

Below is the complete, zero-dependency Python 3.11+ production suite: CurriculumPlannerEngine. It counts syllables, models musical bar timing at 108 BPM, compiles CEFR Pre-A1 song lyrics, and audits budget economics against Google API rate cards.

#!/usr/bin/env python3
"""
CurriculumPlannerEngine - Song Curriculum & Budgeting Suite for Kids Video
Part of Playbook 03: Autonomous Agentic Video Studio (PB-03)

Zero-dependency Python 3.11+ script implementing:
1. English Syllable Counter & Poetic Meter Analyzer (6-8 syllables per line)
2. CEFR Pre-A1 60-Second Nursery Rhyme Lyric Compiler (108 BPM grid)
3. Executive Producer Cost & Token Budget Calculator
4. Programmatic Curriculum Linter certifying meter and budget constraints
"""

import re
from dataclasses import dataclass, field
from typing import List, Dict, Any, Tuple


def count_syllables_english(word: str) -> int:
    """
    Heuristic English syllable counter based on vowel phoneme clusters.
    Zero-dependency implementation calibrated for preschool vocabulary.
    """
    word = word.lower().strip(".:,;!?\"'-")
    if not word:
        return 0
    if len(word) <= 3:
        return 1

    # Specific common preschool words adjustments
    exceptions = {
        "cow": 1, "duck": 1, "sheep": 1, "moo": 1, "quack": 1, "baa": 1,
        "farm": 1, "bus": 1, "wheels": 1, "round": 1, "town": 1, "star": 1,
        "little": 2, "yellow": 2, "friends": 1, "hello": 2, "goodbye": 2,
        "hooray": 2, "listen": 2, "happy": 2, "macdonald": 3
    }
    if word in exceptions:
        return exceptions[word]

    # Handle silent 'e' at end of words
    if word.endswith("e") and not word.endswith("le"):
        word = word[:-1]

    # Count vowel groups
    vowel_runs = re.findall(r"[aeiouy]+", word)
    count = len(vowel_runs)

    return max(1, count)


def count_line_syllables(line: str) -> int:
    """Counts total syllables in a lyric line."""
    words = re.findall(r"\b[\w'-]+\b", line)
    return sum(count_syllables_english(w) for w in words)


@dataclass
class SongLine:
    """Represents a single line of lyrics with musical bar alignment."""
    text: str
    syllable_count: int
    bars: int  # Number of 4/4 bars at 108 BPM (1 bar ~ 2.22s)
    is_valid_meter: bool


@dataclass
class SongVerse:
    """Structured musical verse for a single target vocabulary word."""
    verse_number: int
    target_word: str
    target_sound: str
    duration_sec: float
    lines: List[SongLine]


@dataclass
class MasterCurriculumPlan:
    """Complete 60-second song curriculum manifest."""
    song_title: str
    theme: str
    target_words: List[str]
    tempo_bpm: int
    total_duration_sec: float
    intro_lines: List[SongLine]
    verses: List[SongVerse]
    outro_lines: List[SongLine]


class TokenBudgetCalculator:
    """Calculates Google GenAI media costs and verifies budget compliance."""

    # Google Cloud Production API Rate Cards (v1 / Vertex AI)
    PRICE_GEMINI_38_FLASH_1M_INPUT = 0.15
    PRICE_GEMINI_38_FLASH_1M_OUTPUT = 0.60
    PRICE_GEMINI_38_PRO_1M_INPUT = 1.25
    PRICE_GEMINI_38_PRO_1M_OUTPUT = 5.00
    PRICE_IMAGEN_3_PER_IMAGE = 0.040
    PRICE_VEO_2_PER_5S_CLIP = 0.220
    PRICE_CLOUD_TTS_1M_CHARS = 16.00
    PRICE_LYRIA_PER_60S_TRACK = 0.100

    @classmethod
    def calculate_episode_budget(
        cls,
        shots_count: int = 11,
        keyframes_count: int = 12,
        tts_char_count: int = 500,
        flash_input_tokens: int = 8000,
        flash_output_tokens: int = 4000,
        pro_input_tokens: int = 3000,
        pro_output_tokens: int = 1500
    ) -> Dict[str, float]:
        """Computes comprehensive line-item cost breakdown."""
        cost_flash = (flash_input_tokens / 1e6 * cls.PRICE_GEMINI_38_FLASH_1M_INPUT) + \
                     (flash_output_tokens / 1e6 * cls.PRICE_GEMINI_38_FLASH_1M_OUTPUT)
        cost_pro = (pro_input_tokens / 1e6 * cls.PRICE_GEMINI_38_PRO_1M_INPUT) + \
                   (pro_output_tokens / 1e6 * cls.PRICE_GEMINI_38_PRO_1M_OUTPUT)
        cost_imagen = keyframes_count * cls.PRICE_IMAGEN_3_PER_IMAGE
        cost_veo = shots_count * cls.PRICE_VEO_2_PER_5S_CLIP
        cost_tts = (tts_char_count / 1e6) * cls.PRICE_CLOUD_TTS_1M_CHARS
        cost_lyria = cls.PRICE_LYRIA_PER_60S_TRACK

        total_cost = cost_flash + cost_pro + cost_imagen + cost_veo + cost_tts + cost_lyria

        return {
            "gemini_flash_cost_usd": round(cost_flash, 4),
            "gemini_pro_cost_usd": round(cost_pro, 4),
            "imagen_3_cost_usd": round(cost_imagen, 4),
            "veo_2_cost_usd": round(cost_veo, 4),
            "cloud_tts_cost_usd": round(cost_tts, 4),
            "lyria_music_cost_usd": round(cost_lyria, 4),
            "total_estimated_cost_usd": round(total_cost, 4)
        }


class CurriculumPlannerEngine:
    """Compiles and lints 60-second educational song curricula."""

    def __init__(self, tempo_bpm: int = 108, budget_ceiling_usd: float = 3.50):
        self.tempo_bpm = tempo_bpm
        self.budget_ceiling_usd = budget_ceiling_usd

    def compile_line(self, text: str, bars: int = 2) -> SongLine:
        """Analyzes and compiles a single song line with syllable meter verification."""
        syl = count_line_syllables(text)
        is_valid = 6 <= syl <= 8
        return SongLine(text=text, syllable_count=syl, bars=bars, is_valid_meter=is_valid)

    def generate_farm_animals_curriculum(self) -> MasterCurriculumPlan:
        """Constructs a certified 60-second sing-along song for Farm Animals."""
        # Intro (8.0s = ~4 bars @ 108 BPM)
        intro = [
            self.compile_line("Hello, friends, let's sing a song!"),  # 8 syllables
            self.compile_line("Come and visit on the farm!")        # 7 syllables
        ]

        # 3 Verses (14.0s each = ~6 bars)
        verses = [
            SongVerse(
                verse_number=1,
                target_word="Cow",
                target_sound="Moo",
                duration_sec=14.0,
                lines=[
                    self.compile_line("Old MacDonald had a cow,"),       # 7 syllables
                    self.compile_line("The cow says moo, moo, moo!"),    # 7 syllables
                    self.compile_line("Can you say cow? Yes, a cow!")     # 7 syllables
                ]
            ),
            SongVerse(
                verse_number=2,
                target_word="Duck",
                target_sound="Quack",
                duration_sec=14.0,
                lines=[
                    self.compile_line("Old MacDonald had a duck,"),      # 7 syllables
                    self.compile_line("The duck says quack, quack, quack!"), # 7 syllables
                    self.compile_line("Can you say duck? Yes, a duck!")   # 7 syllables
                ]
            ),
            SongVerse(
                verse_number=3,
                target_word="Sheep",
                target_sound="Baa",
                duration_sec=14.0,
                lines=[
                    self.compile_line("Old MacDonald had a sheep,"),     # 7 syllables
                    self.compile_line("The sheep says baa, baa, baa!"),  # 7 syllables
                    self.compile_line("Can you say sheep? Yes, a sheep!") # 7 syllables
                ]
            )
        ]

        # Outro Dance (10.0s = ~5 bars)
        outro = [
            self.compile_line("Great job singing on the farm!"),  # 8 syllables
            self.compile_line("Goodbye, friends, see you soon!")  # 6 syllables
        ]

        return MasterCurriculumPlan(
            song_title="Old MacDonald's Phonics Farm",
            theme="Farm Animals",
            target_words=["Cow", "Duck", "Sheep"],
            tempo_bpm=self.tempo_bpm,
            total_duration_sec=60.0,
            intro_lines=intro,
            verses=verses,
            outro_lines=outro
        )

    def audit_curriculum_plan(
        self,
        plan: MasterCurriculumPlan,
        budget: Dict[str, float]
    ) -> Tuple[bool, List[str]]:
        """Audits song curriculum against poetic meter and financial safety bounds."""
        violations = []

        # 1. Check all lyric lines for 6-8 syllable constraint
        all_lines = list(plan.intro_lines) + list(plan.outro_lines)
        for v in plan.verses:
            all_lines.extend(v.lines)

        for idx, line in enumerate(all_lines, start=1):
            if not line.is_valid_meter:
                violations.append(
                    f"[Line {idx}] '{line.text}' has {line.syllable_count} syllables (Must be between 6 and 8)."
                )

        # 2. Check duration math (8.0s + 3 * 14.0s + 10.0s == 60.0s)
        verse_dur = sum(v.duration_sec for v in plan.verses)
        computed_duration = 8.0 + verse_dur + 10.0
        if round(computed_duration, 1) != 60.0:
            violations.append(f"Total duration {computed_duration}s does not equal 60.0s.")

        # 3. Check Target Word Repetition (at least 3 per verse)
        for v in plan.verses:
            joined_verse = " ".join(l.text.lower() for l in v.lines)
            occurrences = len(re.findall(rf"\b{v.target_word.lower()}\b", joined_verse))
            if occurrences < 3:
                violations.append(
                    f"[Verse {v.verse_number}] Target word '{v.target_word}' appears only {occurrences} times (min 3 required)."
                )

        # 4. Check Financial Budget Ceiling ($3.50)
        total_cost = budget["total_estimated_cost_usd"]
        if total_cost > self.budget_ceiling_usd:
            violations.append(
                f"Total estimated episode cost ${total_cost:.3f} exceeds ceiling ${self.budget_ceiling_usd:.2f}."
            )

        is_valid = len(violations) == 0
        return is_valid, violations


# =====================================================================
# VERIFICATION SUITE & DEMO EXECUTION
# =====================================================================

if __name__ == "__main__":
    print("=== Chapter 2 Lab: Song Curriculum & Token Budgeting Verification ===\n")

    planner = CurriculumPlannerEngine(tempo_bpm=108, budget_ceiling_usd=3.50)

    # 1. Generate Song Curriculum
    plan = planner.generate_farm_animals_curriculum()
    print(f"[1] Compiled Song Curriculum: '{plan.song_title}'")
    print(f"  Theme: {plan.theme} | Target Words: {', '.join(plan.target_words)}")
    print(f"  Target Tempo: {plan.tempo_bpm} BPM | Total Duration: {plan.total_duration_sec}s\n")

    print("[2] Syllable Meter Inspection:")
    for v in plan.verses:
        print(f"  - [Verse {v.verse_number}] Target: '{v.target_word}' ({v.duration_sec}s):")
        for line in v.lines:
            meter_status = "OK" if line.is_valid_meter else "FAIL"
            print(f"      * [{line.syllable_count:2d} syl | {meter_status}]: \"{line.text}\"")
        print()

    # 2. Compute Executive Producer Cost Budget
    budget = TokenBudgetCalculator.calculate_episode_budget()
    print("[3] Executive Producer Cost & Token Budget Breakdown:")
    for item, cost in budget.items():
        print(f"  - {item:28s}: ${cost:.4f}")
    print(f"  >>> Budget Ceiling: ${planner.budget_ceiling_usd:.2f}\n")

    # 3. Programmatic Curriculum & Budget Audit
    print("[4] Executing Programmatic Curriculum Audit:")
    is_valid, violations = planner.audit_curriculum_plan(plan, budget)
    if is_valid:
        print("  >>> PASSED: 100% of Song Lines satisfy 6-8 Syllable Meter Constraints.")
        print("  >>> PASSED: Exact 60.0s Episode Timing Certified.")
        print("  >>> PASSED: Target Words Repeat >= 3 times per verse.")
        print("  >>> PASSED: Episode Cost ($3.02) Safely Clamped below $3.50 Budget Ceiling.\n")
    else:
        print(f"  >>> FAILED: {len(violations)} Violations:")
        for v in violations:
            print(f"      - {v}")
    assert is_valid, f"Curriculum audit failed: {violations}"

    print("\n[PASS] Verification Lab Passed: Curriculum Planner Engine Certified.")

8. Summary & Next Steps

In this chapter, we established the pedagogical curriculum and resource management foundations for the virtual studio:

• Prosodic Bootstrapping: Aligned language learning lyrics to 108 BPM musical downbeats, making syllable boundaries audible for toddlers.
• 6-to-8 Syllable Meter Law: Clamped all lyrics to 6–8 syllables per line, preventing audio tripping and vocal slurring.
• Executive Producer Economics: Verified complete 60-second episode budget modeling, proving production viability at ~$3.02 against a $3.50 ceiling.
• Production Automation: Tested and verified CurriculumPlannerEngine, certifying 100% compliance across syllable meter, word repetition, and financial constraints.

In Chapter 3, we build The Music & Lyricist Agent, transforming these metered lyrics into 108 BPM audio stems with Google DeepMind Lyria and MusicFX.