feat: add dynamic story pacing

app.py

@@ -5,13 +5,18 @@ from time import sleep
 import gradio as gr
 
 from puppet_theater import (
+    DEFAULT_SHOW_LENGTH,
     DEFAULT_HF_API_MODEL_ID,
     DEFAULT_OPENBMB_MODEL_ID,
+    SHOW_LENGTH_PRESETS,
     TheaterSession,
     create_show_from_premise,
     get_backend_status,
     request_finale,
+    resolve_show_length,
     run_one_beat,
+    story_phase,
+    story_progress,
     summon_actor,
     throw_prop,
     warm_up_openbmb,
@@ -44,6 +49,7 @@ EMPTY_TRACE = "No trace events yet."
 EMPTY_BACKEND = (
     "Active backend: deterministic\n"
     "Director mode: deterministic\n"
+    "Show length: min=7, target=10, max=12\n"
     "Available actor backends: deterministic, local OpenBMB, Hugging Face API\n"
     "Available director modes: deterministic, LLM / HF API\n"
     "OpenBMB model id: openbmb/MiniCPM5-1B\n"
@@ -74,6 +80,12 @@ HF_API_MODEL_ID = os.getenv("HF_API_MODEL_ID", DEFAULT_HF_API_MODEL_ID)
 DEFAULT_MAX_NEW_TOKENS = 120
 DEFAULT_TEMPERATURE = 0.75
 PLAYBACK_DELAY_SECONDS = 0.75
+SHOW_LENGTH_CHOICES = [
+    ("Short", "short"),
+    ("Standard", "standard"),
+    ("Extended", "extended"),
+]
+SHOW_LENGTH_VALUES = set(SHOW_LENGTH_PRESETS)
 PROP_EMOJI = {
     "rubber duck": "🐤",
     "duck": "🐤",
@@ -1547,6 +1559,9 @@ def render_stage(session: TheaterSession | None) -> str:
         </div>
         """
 
+    phase = story_phase(session)
+    progress_percent = round(story_progress(session) * 100)
+    performed_beats = len(session.transcript)
     curtain_html = ""
     if show_opening_curtain:
         curtain_html = """
@@ -1564,7 +1579,8 @@ def render_stage(session: TheaterSession | None) -> str:
         <div class="stage-marquee">{escape(session.show_title)}</div>
         <div class="stage-copy">
           <strong>Setting:</strong> {escape(session.setting)}<br />
-          <strong>Premise:</strong> {escape(session.premise)}
+          <strong>Premise:</strong> {escape(session.premise)}<br />
+          <strong>Phase:</strong> {escape(phase.title())} · <strong>Progress:</strong> {progress_percent}%
         </div>
         <div class="actor-row">
           {''.join(actor_columns)}
@@ -1573,7 +1589,7 @@ def render_stage(session: TheaterSession | None) -> str:
           {audience_action}
           {prop_pile}
         </div>
-        <div class="beat-counter">Beat {session.beat_index} of {session.max_beats}</div>
+        <div class="beat-counter">Beat {performed_beats} of {session.max_beats} · target {session.target_beats} · {escape(phase.title())}</div>
       </div>
       <div class="stage-floorboards"></div>
     </div>
@@ -1614,6 +1630,10 @@ def normalize_director_mode(director_mode: str | None) -> str:
     return director_mode if director_mode in DIRECTOR_MODE_VALUES else "deterministic"
 
 
+def normalize_show_length(show_length: str | None) -> str:
+    return show_length if show_length in SHOW_LENGTH_VALUES else DEFAULT_SHOW_LENGTH
+
+
 def normalize_max_new_tokens(max_new_tokens: int | float | None) -> int:
     if max_new_tokens is None:
         return DEFAULT_MAX_NEW_TOKENS
@@ -1660,6 +1680,11 @@ def render_backend_settings(
     active_backend = session.backend_name if session is not None else selected_backend
     active_director_mode = session.director_mode if session is not None else selected_director_mode
     active_model_id = session.backend_model_id if session is not None else None
+    min_beats, target_beats, max_beats = (
+        (session.min_beats, session.target_beats, session.max_beats)
+        if session is not None
+        else resolve_show_length(DEFAULT_SHOW_LENGTH)[1:]
+    )
     if active_backend == "openbmb" or active_director_mode == "openbmb":
         active_model_id = active_model_id or OPENBMB_MODEL_ID
     if active_backend == "hf_api" or active_director_mode == "hf_api":
@@ -1684,6 +1709,7 @@ def render_backend_settings(
     return (
         f"Active backend: {active_backend}\n"
         f"Director mode: {active_director_mode}\n"
+        f"Show length: min={min_beats}, target={target_beats}, max={max_beats}\n"
         "Available actor backends: deterministic, local OpenBMB, Hugging Face API\n"
         "Available director modes: deterministic, LLM / HF API\n"
         f"Active model id: {active_model_id or 'not selected'}\n"
@@ -1721,12 +1747,14 @@ def render_outputs(session: TheaterSession | None):
 def create_show(
     premise: str,
     session: TheaterSession | None,
+    show_length: str,
     backend_name: str,
     director_mode: str,
     max_new_tokens: int | float,
     temperature: int | float,
 ):
     premise = premise.strip()
+    selected_show_length = normalize_show_length(show_length)
     selected_backend = normalize_backend_name(backend_name)
     selected_director_mode = normalize_director_mode(director_mode)
     selected_max_new_tokens = normalize_max_new_tokens(max_new_tokens)
@@ -1761,6 +1789,7 @@ def create_show(
         backend_max_new_tokens=selected_max_new_tokens,
         backend_temperature=selected_temperature,
         director_mode=selected_director_mode,
+        show_length=selected_show_length,
     )
     return session, *render_outputs(session)
 
@@ -1776,6 +1805,7 @@ def reset_show():
         EMPTY_DIRECTOR_LOG,
         EMPTY_TRACE,
         None,
+        DEFAULT_SHOW_LENGTH,
         "deterministic",
         "deterministic",
         DEFAULT_MAX_NEW_TOKENS,
@@ -2014,6 +2044,12 @@ with gr.Blocks(title="AI Puppet Theater") as app:
                 placeholder="A moon detective interrogates a suspicious toaster...",
                 lines=1,
             )
+            show_length_select = gr.Dropdown(
+                choices=SHOW_LENGTH_CHOICES,
+                value=DEFAULT_SHOW_LENGTH,
+                label="Show Length",
+                interactive=True,
+            )
             with gr.Row(elem_classes=["premise-actions"]):
                 create_button = gr.Button("Create Show", variant="primary", elem_classes=["primary-action"])
                 reset_button = gr.Button("Reset", elem_classes=["reset-action"])
@@ -2135,6 +2171,7 @@ with gr.Blocks(title="AI Puppet Theater") as app:
         inputs=[
             premise_input,
             session_state,
+            show_length_select,
             backend_select,
             director_mode_select,
             max_new_tokens_input,
@@ -2265,6 +2302,7 @@ with gr.Blocks(title="AI Puppet Theater") as app:
             director_output,
             trace_output,
             trace_download,
+            show_length_select,
             backend_select,
             director_mode_select,
             max_new_tokens_input,

puppet_theater/__init__.py

@@ -21,9 +21,11 @@ from puppet_theater.director import (
     choose_director_decision,
     run_full_act,
     run_one_beat,
+    story_phase,
+    story_progress,
 )
 from puppet_theater.models import Actor, ActorResponse, Beat, DirectorDecision, TheaterSession
-from puppet_theater.session import create_show_from_premise
+from puppet_theater.session import DEFAULT_SHOW_LENGTH, SHOW_LENGTH_PRESETS, create_show_from_premise, resolve_show_length
 
 __all__ = [
     "Actor",
@@ -33,6 +35,7 @@ __all__ = [
     "DEFAULT_HF_API_MODEL",
     "DEFAULT_HF_API_MODEL_ID",
     "DEFAULT_OPENBMB_MODEL_ID",
+    "DEFAULT_SHOW_LENGTH",
     "DeterministicBackend",
     "DirectorDecision",
     "DirectorGeneration",
@@ -42,6 +45,7 @@ __all__ = [
     "ModelBackend",
     "OpenBMBDirectorPolicy",
     "OpenBMBTransformersBackend",
+    "SHOW_LENGTH_PRESETS",
     "TheaterSession",
     "create_show_from_premise",
     "choose_director_decision",
@@ -49,8 +53,11 @@ __all__ = [
     "get_backend_status",
     "parse_actor_output",
     "request_finale",
+    "resolve_show_length",
     "run_full_act",
     "run_one_beat",
+    "story_phase",
+    "story_progress",
     "summon_actor",
     "throw_prop",
     "warm_up_openbmb",

puppet_theater/director.py

@@ -29,6 +29,34 @@ BEAT_ARC = [
     "finale",
 ]
 
+STORY_PHASES = ["opening", "complication", "reveal", "chaos", "finale"]
+
+
+def story_progress(session: TheaterSession) -> float:
+    target_beats = max(1, session.target_beats)
+    return min(1.0, max(0.0, session.beat_index / target_beats))
+
+
+def story_phase(session: TheaterSession) -> str:
+    progress = story_progress(session)
+    if progress < 0.20:
+        return "opening"
+    if progress < 0.45:
+        return "complication"
+    if progress < 0.65:
+        return "reveal"
+    if progress < 0.85:
+        return "chaos"
+    return "finale"
+
+
+def should_force_finale(session: TheaterSession) -> bool:
+    return (
+        session.finale_requested
+        or session.beat_index >= session.target_beats - 1
+        or session.beat_index >= session.max_beats - 1
+    )
+
 
 @dataclass(frozen=True)
 class DirectorGeneration:
@@ -44,7 +72,9 @@ class DirectorGeneration:
 
 class DirectorPolicy:
     def decide(self, session: TheaterSession) -> DirectorDecision:
-        if session.finale_requested or session.beat_index >= session.max_beats - 1:
+        phase = story_phase(session)
+        progress = story_progress(session)
+        if should_force_finale(session):
             speaker = self._choose_speaker(session)
             return DirectorDecision(
                 next_speaker=speaker.name,
@@ -52,7 +82,7 @@ class DirectorPolicy:
                 instruction="Tie the scene together in one crisp curtain-call line.",
                 stage_effect="curtain_fall",
                 should_end_scene=True,
-                reason_summary="Finale requested or final beat reached; closing the scene cleanly.",
+                reason_summary="Finale requested, target reached, or final beat reached; closing cleanly.",
             )
 
         if session.latest_prop is not None:
@@ -76,7 +106,7 @@ class DirectorPolicy:
                 reason_summary=f"Newly summoned actor {summoned_actor.name} has not spoken yet.",
             )
 
-        beat_type = BEAT_ARC[min(session.beat_index, len(BEAT_ARC) - 1)]
+        beat_type = self._beat_type_for_phase(phase, session)
         speaker = self._choose_speaker(session)
         reveal_secret = beat_type == "secret_reveal"
         return DirectorDecision(
@@ -86,7 +116,7 @@ class DirectorPolicy:
             stage_effect=self._effect_for_beat(beat_type),
             reveal_secret=reveal_secret,
             should_end_scene=beat_type == "finale",
-            reason_summary=f"Following the compact six-beat arc with {beat_type}.",
+            reason_summary=f"Following {phase} phase at {progress:.0%} progress with {beat_type}.",
         )
 
     def _choose_speaker(self, session: TheaterSession) -> Actor:
@@ -127,6 +157,17 @@ class DirectorPolicy:
             "finale": "curtain_fall",
         }[beat_type]
 
+    def _beat_type_for_phase(self, phase: str, session: TheaterSession) -> str:
+        if phase == "opening":
+            return "setup" if session.beat_index == 0 else "denial_or_contradiction"
+        if phase == "complication":
+            return "evidence_or_prop" if session.beat_index % 2 == 0 else "denial_or_contradiction"
+        if phase == "reveal":
+            return "secret_reveal"
+        if phase == "chaos":
+            return "chaos_or_intervention"
+        return "chaos_or_intervention"
+
 
 class OpenBMBDirectorPolicy:
     def __init__(self, fallback_policy: DirectorPolicy | None = None) -> None:
@@ -353,6 +394,8 @@ def run_one_beat(session: TheaterSession | None) -> TheaterSession | None:
         )
         return session
 
+    current_phase = story_phase(session)
+    current_progress = story_progress(session)
     director_generation = choose_director_decision(session)
     decision = director_generation.decision
     speaker = _actor_by_name(session, decision.next_speaker)
@@ -364,6 +407,10 @@ def run_one_beat(session: TheaterSession | None) -> TheaterSession | None:
         "Director decision: "
         f"{decision.beat_type} for {speaker.name}; {decision.reason_summary}"
     )
+    session.director_log.append(
+        f"Story phase {current_phase} at {current_progress:.0%} progress "
+        f"(min={session.min_beats}, target={session.target_beats}, max={session.max_beats})."
+    )
     session.director_log.append(
         "Director mode "
         f"{director_generation.director_mode} "
@@ -386,6 +433,11 @@ def run_one_beat(session: TheaterSession | None) -> TheaterSession | None:
         fallback_used=director_generation.fallback_used,
         fallback_reason=director_generation.error,
         reason_summary=director_generation.reason_summary,
+        story_phase=current_phase,
+        progress=round(current_progress, 3),
+        min_beats=session.min_beats,
+        target_beats=session.target_beats,
+        max_beats=session.max_beats,
         uses_prop=decision.uses_prop,
         reveal_secret=decision.reveal_secret,
         should_end_scene=decision.should_end_scene,
@@ -441,6 +493,8 @@ def run_one_beat(session: TheaterSession | None) -> TheaterSession | None:
         beat_type=decision.beat_type,
         speaker=speaker.name,
         stage_effect=beat.stage_effect,
+        story_phase=story_phase(session),
+        progress=round(story_progress(session), 3),
     )
     add_trace_event(
         session,
@@ -476,6 +530,7 @@ def run_one_beat(session: TheaterSession | None) -> TheaterSession | None:
             session,
             "scene_completed",
             beat_index=session.beat_index,
+            story_phase="finale",
             reason_summary="Finale reached; curtain falls cleanly.",
         )
 
@@ -514,7 +569,11 @@ def build_director_prompt(session: TheaterSession) -> str:
         premise=session.premise,
         setting=session.setting,
         beat_index=session.beat_index,
+        min_beats=session.min_beats,
+        target_beats=session.target_beats,
         max_beats=session.max_beats,
+        current_progress=f"{story_progress(session):.0%}",
+        story_phase=story_phase(session),
         allowed_beat_types=", ".join(BEAT_ARC),
         actor_profiles=actor_profiles,
         recent_transcript=recent_transcript,
@@ -562,12 +621,17 @@ def validate_director_decision(decision: DirectorDecision, session: TheaterSessi
         return None, "invalid_too_long"
 
     update: dict[str, object] = {}
-    if session.finale_requested or session.beat_index >= session.max_beats - 1:
+    if should_force_finale(session):
         update["beat_type"] = "finale"
         update["should_end_scene"] = True
         update["stage_effect"] = "curtain_fall"
-    elif decision.should_end_scene and session.beat_index < session.max_beats - 2:
-        update["should_end_scene"] = False
+    else:
+        if decision.should_end_scene and session.beat_index < session.target_beats - 1:
+            update["should_end_scene"] = False
+        if decision.beat_type == "finale" and session.beat_index < session.target_beats - 1:
+            update["beat_type"] = _safe_non_finale_beat_type(session)
+            update["should_end_scene"] = False
+            update["stage_effect"] = DirectorPolicy()._effect_for_beat(str(update["beat_type"]))
     if decision.uses_prop and session.latest_prop is None:
         update["uses_prop"] = False
     if decision.beat_type == "secret_reveal":
@@ -578,6 +642,17 @@ def validate_director_decision(decision: DirectorDecision, session: TheaterSessi
     return decision, "valid"
 
 
+def _safe_non_finale_beat_type(session: TheaterSession) -> str:
+    phase = story_phase(session)
+    if phase == "opening":
+        return "setup"
+    if phase == "complication":
+        return "evidence_or_prop"
+    if phase == "reveal":
+        return "secret_reveal"
+    return "chaos_or_intervention"
+
+
 def _coerce_director_output(raw_output: object) -> dict[str, object] | None:
     if isinstance(raw_output, DirectorDecision):
         return raw_output.model_dump()

puppet_theater/models.py

@@ -97,7 +97,9 @@ class TheaterSession:
     session_id: str = field(default_factory=lambda: uuid4().hex[:12])
     created_at: str = field(default_factory=lambda: datetime.now(timezone.utc).isoformat())
     beat_index: int = 0
-    max_beats: int = 6
+    min_beats: int = 7
+    target_beats: int = 10
+    max_beats: int = 12
     transcript: list[Beat] = field(default_factory=list)
     props: list[str] = field(default_factory=list)
     latest_prop: str | None = None

puppet_theater/prompts.py

@@ -46,7 +46,11 @@ Show title: {show_title}
 Premise: {premise}
 Setting: {setting}
 Current beat: {beat_index}
+Minimum beats before normal ending: {min_beats}
+Target beats: {target_beats}
 Maximum beats: {max_beats}
+Current progress: {current_progress}
+Story phase: {story_phase}
 Allowed beat types: {allowed_beat_types}
 Available actors:
 {actor_profiles}

puppet_theater/session.py

@@ -2,6 +2,22 @@ from puppet_theater.models import Actor, TheaterSession
 from puppet_theater.trace import add_trace_event
 
 
+SHOW_LENGTH_PRESETS: dict[str, tuple[int, int, int]] = {
+    "short": (5, 7, 8),
+    "standard": (7, 10, 12),
+    "extended": (10, 14, 16),
+}
+DEFAULT_SHOW_LENGTH = "standard"
+
+
+def resolve_show_length(show_length: str | None = None) -> tuple[str, int, int, int]:
+    normalized = (show_length or DEFAULT_SHOW_LENGTH).strip().lower()
+    if normalized not in SHOW_LENGTH_PRESETS:
+        normalized = DEFAULT_SHOW_LENGTH
+    min_beats, target_beats, max_beats = SHOW_LENGTH_PRESETS[normalized]
+    return normalized, min_beats, target_beats, max_beats
+
+
 def _clean_premise(premise: str) -> str:
     cleaned = " ".join(premise.strip().split())
     return cleaned or "A mysterious puppet show with no premise"
@@ -35,10 +51,12 @@ def create_show_from_premise(
     backend_max_new_tokens: int = 120,
     backend_temperature: float = 0.75,
     director_mode: str = "deterministic",
+    show_length: str = DEFAULT_SHOW_LENGTH,
 ) -> TheaterSession:
     cleaned_premise = _clean_premise(premise)
     show_title = _title_from_premise(cleaned_premise)
     setting = _setting_from_premise(cleaned_premise)
+    active_show_length, min_beats, target_beats, max_beats = resolve_show_length(show_length)
 
     actors = [
         Actor(
@@ -72,9 +90,10 @@ def create_show_from_premise(
     active_director_mode = director_mode if director_mode in supported_generation_modes else "deterministic"
     model_note = f" ({backend_model_id})" if backend_model_id else ""
     director_log = [
-        "Director created a deterministic six-beat show plan.",
+        f"Director created a {active_show_length} show plan.",
         f"Active backend: {active_backend}{model_note}.",
         f"Director mode: {active_director_mode}.",
+        f"Show length: min {min_beats}, target {target_beats}, max {max_beats} beats.",
         f"Setting selected: {setting}.",
         "Three puppet actors are waiting for the first beat.",
     ]
@@ -84,7 +103,9 @@ def create_show_from_premise(
         setting=setting,
         actors=actors,
         beat_index=0,
-        max_beats=6,
+        min_beats=min_beats,
+        target_beats=target_beats,
+        max_beats=max_beats,
         transcript=[],
         props=[],
         latest_prop=None,
@@ -105,6 +126,10 @@ def create_show_from_premise(
         backend_name=active_backend,
         model_id=backend_model_id,
         director_mode=active_director_mode,
+        show_length=active_show_length,
+        min_beats=min_beats,
+        target_beats=target_beats,
+        max_beats=max_beats,
         actor_count=len(actors),
         validation_status="valid",
         fallback_used=False,
@@ -114,6 +139,7 @@ def create_show_from_premise(
         session,
         "director_plan_created",
         director_mode=active_director_mode,
-        reason_summary="Deterministic six-beat show plan created.",
+        story_phase="opening",
+        reason_summary=f"{active_show_length.title()} progress-based show plan created.",
     )
     return session

puppet_theater/trace.py

@@ -49,6 +49,9 @@ def export_trace(session: TheaterSession | None) -> dict[str, Any] | None:
         "premise": sanitize_value(session.premise),
         "title": sanitize_value(session.show_title),
         "setting": sanitize_value(session.setting),
+        "min_beats": session.min_beats,
+        "target_beats": session.target_beats,
+        "max_beats": session.max_beats,
         "active_backend": sanitize_value(session.backend_name),
         "actor_backend": sanitize_value(session.backend_name),
         "director_mode": sanitize_value(session.director_mode),

tests/test_director.py

@@ -5,9 +5,18 @@ from puppet_theater.director import (
     build_director_prompt,
     choose_director_decision,
     parse_director_decision,
+    run_full_act,
+    story_phase,
 )
 from puppet_theater.models import DirectorDecision
-from puppet_theater.session import create_show_from_premise
+from puppet_theater.session import create_show_from_premise, resolve_show_length
+
+
+def test_show_length_presets_are_resolved() -> None:
+    assert resolve_show_length("short") == ("short", 5, 7, 8)
+    assert resolve_show_length("standard") == ("standard", 7, 10, 12)
+    assert resolve_show_length("extended") == ("extended", 10, 14, 16)
+    assert resolve_show_length("unknown") == ("standard", 7, 10, 12)
 
 
 def test_director_prompt_includes_audience_context_and_schema() -> None:
@@ -25,10 +34,30 @@ def test_director_prompt_includes_audience_context_and_schema() -> None:
     assert "Audience summoned Professor Button." in prompt
     assert "Professor Button" in prompt
     assert "Has already misplaced the final cue card." in prompt
+    assert "Minimum beats before normal ending: 7" in prompt
+    assert "Target beats: 10" in prompt
+    assert "Maximum beats: 12" in prompt
+    assert "Current progress: 0%" in prompt
+    assert "Story phase: opening" in prompt
     assert '"next_speaker"' in prompt
     assert "Allowed beat types: " in prompt
 
 
+def test_story_phase_uses_target_progress() -> None:
+    session = create_show_from_premise("A teacup files a weather report", show_length="standard")
+
+    session.beat_index = 0
+    assert story_phase(session) == "opening"
+    session.beat_index = 2
+    assert story_phase(session) == "complication"
+    session.beat_index = 5
+    assert story_phase(session) == "reveal"
+    session.beat_index = 7
+    assert story_phase(session) == "chaos"
+    session.beat_index = 9
+    assert story_phase(session) == "finale"
+
+
 def test_invalid_llm_speaker_is_rejected() -> None:
     session = create_show_from_premise("A castle argues with a thunderstorm")
     raw_decision = {
@@ -83,8 +112,9 @@ def test_finale_request_forces_bounded_finale_decision() -> None:
     assert decision.stage_effect == "curtain_fall"
 
 
-def test_early_should_end_scene_is_bounded() -> None:
+def test_early_should_end_scene_is_bounded_until_target() -> None:
     session = create_show_from_premise("A teacup runs for mayor")
+    session.beat_index = session.min_beats - 1
     decision = DirectorDecision(
         next_speaker=session.actors[0].name,
         beat_type="setup",
@@ -99,3 +129,79 @@ def test_early_should_end_scene_is_bounded() -> None:
     assert status == "valid"
     assert validated is not None
     assert validated.should_end_scene is False
+
+
+def test_early_llm_finale_is_rewritten_before_target() -> None:
+    session = create_show_from_premise("A lighthouse hosts a talent show")
+    decision = DirectorDecision(
+        next_speaker=session.actors[0].name,
+        beat_type="finale",
+        instruction="End immediately.",
+        stage_effect="curtain_fall",
+        should_end_scene=True,
+        reason_summary="The model tried to close early.",
+    )
+
+    validated, status = parse_director_decision(decision, session)
+
+    assert status == "valid"
+    assert validated is not None
+    assert validated.beat_type != "finale"
+    assert validated.should_end_scene is False
+
+
+def test_full_act_standard_runs_to_target_and_stays_bounded() -> None:
+    session = create_show_from_premise("A moon detective interrogates a suspicious toaster")
+
+    run_full_act(session)
+
+    assert len(session.transcript) == session.target_beats
+    assert len(session.transcript) > 6
+    assert session.beat_index == session.max_beats
+    assert len(session.transcript) <= session.max_beats
+    assert session.transcript[-1].stage_effect == "curtain_fall"
+
+
+def test_length_presets_change_full_act_bounds() -> None:
+    short_session = create_show_from_premise("A tiny crown demands applause", show_length="short")
+    extended_session = create_show_from_premise("A telescope opens a bakery", show_length="extended")
+
+    run_full_act(short_session)
+    run_full_act(extended_session)
+
+    assert (short_session.min_beats, short_session.target_beats, short_session.max_beats) == (5, 7, 8)
+    assert (extended_session.min_beats, extended_session.target_beats, extended_session.max_beats) == (10, 14, 16)
+    assert len(short_session.transcript) == 7
+    assert len(extended_session.transcript) == 14
+    assert len(extended_session.transcript) <= extended_session.max_beats
+
+
+def test_finale_request_can_end_before_minimum() -> None:
+    session = create_show_from_premise("A spoon wants a curtain call", show_length="extended")
+    session = request_finale(session)
+
+    run_full_act(session)
+
+    assert len(session.transcript) == 1
+    assert session.transcript[-1].stage_effect == "curtain_fall"
+
+
+def test_llm_decision_is_forced_to_finale_at_max() -> None:
+    session = create_show_from_premise("A clock refuses bedtime", show_length="short")
+    session.beat_index = session.max_beats - 1
+    decision = DirectorDecision(
+        next_speaker=session.actors[0].name,
+        beat_type="chaos_or_intervention",
+        instruction="Keep escalating.",
+        stage_effect="confetti_rustle",
+        should_end_scene=False,
+        reason_summary="The model tried to continue at the hard bound.",
+    )
+
+    validated, status = parse_director_decision(decision, session)
+
+    assert status == "valid"
+    assert validated is not None
+    assert validated.beat_type == "finale"
+    assert validated.should_end_scene is True
+    assert validated.stage_effect == "curtain_fall"