feat: add agentic actor state

app.py

@@ -44,6 +44,7 @@ EMPTY_STAGE = """
 """
 
 EMPTY_TRANSCRIPT = "No show yet. The transcript will appear here."
+EMPTY_AGENT_STATE = "<div class=\"agent-state-empty\">No agents on stage yet.</div>"
 EMPTY_DIRECTOR_LOG = "No director notes yet."
 EMPTY_TRACE = "No trace events yet."
 EMPTY_BACKEND = (
@@ -1018,6 +1019,38 @@ body,
     border: none !important;
     box-shadow: none !important;
 }
+.agent-state-grid {
+    display: grid;
+    gap: 0.55rem;
+    grid-template-columns: repeat(auto-fit, minmax(13rem, 1fr));
+}
+.agent-state-card {
+    background: rgba(10, 12, 23, 0.72);
+    border: 1px solid rgba(246, 196, 83, 0.22);
+    border-radius: 8px;
+    box-sizing: border-box;
+    padding: 0.62rem 0.68rem;
+}
+.agent-state-name {
+    color: #ffd166;
+    font-weight: 800;
+    line-height: 1.2;
+    margin-bottom: 0.28rem;
+}
+.agent-state-line {
+    color: #f8efe4;
+    font-size: 0.78rem;
+    line-height: 1.35;
+    overflow-wrap: anywhere;
+}
+.agent-state-line strong {
+    color: #d8c6b6;
+}
+.agent-state-empty {
+    color: #cbb7a1;
+    font-size: 0.86rem;
+    padding: 0.35rem 0;
+}
 .gradio-container .accordion {
     background: rgba(13, 6, 14, 0.72) !important;
     border: 1px solid rgba(246, 196, 83, 0.22) !important;
@@ -1612,6 +1645,31 @@ def render_transcript(session: TheaterSession | None) -> str:
     return "\n".join(transcript_lines)
 
 
+def render_agent_state(session: TheaterSession | None) -> str:
+    if session is None:
+        return EMPTY_AGENT_STATE
+
+    cards: list[str] = []
+    for actor in session.actors:
+        held_props = actor.held_props or ([actor.held_prop] if actor.held_prop else [])
+        held = ", ".join(held_props) if held_props else "none"
+        recent_memory = actor.recent_memory[-1] if actor.recent_memory else "No memory yet."
+        current_goal = actor.current_goal or actor.goal
+        cards.append(
+            f"""
+            <div class="agent-state-card">
+              <div class="agent-state-name">{escape(actor.avatar)} {escape(actor.name)}</div>
+              <div class="agent-state-line"><strong>Mood:</strong> {escape(actor.mood)}</div>
+              <div class="agent-state-line"><strong>Goal:</strong> {escape(current_goal)}</div>
+              <div class="agent-state-line"><strong>Props:</strong> {escape(held)}</div>
+              <div class="agent-state-line"><strong>Secret:</strong> {escape(actor.secret_status)}</div>
+              <div class="agent-state-line"><strong>Memory:</strong> {escape(recent_memory)}</div>
+            </div>
+            """
+        )
+    return f'<div class="agent-state-grid">{"".join(cards)}</div>'
+
+
 def render_director_log(session: TheaterSession | None) -> str:
     if session is None:
         return EMPTY_DIRECTOR_LOG
@@ -1737,6 +1795,7 @@ def render_outputs(session: TheaterSession | None):
     return (
         render_stage(session),
         render_transcript(session),
+        render_agent_state(session),
         render_director_log(session),
         render_trace(session),
         write_trace_json_file(session),
@@ -1764,6 +1823,7 @@ def create_show(
             None,
             EMPTY_STAGE,
             "No premise yet. Add a premise to raise the curtain.",
+            EMPTY_AGENT_STATE,
             EMPTY_DIRECTOR_LOG,
             EMPTY_TRACE,
             None,
@@ -1802,6 +1862,7 @@ def reset_show():
         "",
         EMPTY_STAGE,
         EMPTY_TRANSCRIPT,
+        EMPTY_AGENT_STATE,
         EMPTY_DIRECTOR_LOG,
         EMPTY_TRACE,
         None,
@@ -1827,6 +1888,7 @@ def advance_one_beat(
             None,
             EMPTY_STAGE,
             "Create a show before running a beat.",
+            EMPTY_AGENT_STATE,
             EMPTY_DIRECTOR_LOG,
             EMPTY_TRACE,
             None,
@@ -1851,6 +1913,7 @@ def advance_full_act(
             None,
             EMPTY_STAGE,
             "Create a show before running the full act.",
+            EMPTY_AGENT_STATE,
             EMPTY_DIRECTOR_LOG,
             EMPTY_TRACE,
             None,
@@ -1915,6 +1978,7 @@ def throw_audience_prop(
             None,
             EMPTY_STAGE,
             "Create a show before throwing a prop.",
+            EMPTY_AGENT_STATE,
             EMPTY_DIRECTOR_LOG,
             EMPTY_TRACE,
             None,
@@ -1939,6 +2003,7 @@ def summon_audience_actor(
             None,
             EMPTY_STAGE,
             "Create a show before summoning an actor.",
+            EMPTY_AGENT_STATE,
             EMPTY_DIRECTOR_LOG,
             EMPTY_TRACE,
             None,
@@ -1962,6 +2027,7 @@ def request_audience_finale(
             None,
             EMPTY_STAGE,
             "Create a show before requesting a finale.",
+            EMPTY_AGENT_STATE,
             EMPTY_DIRECTOR_LOG,
             EMPTY_TRACE,
             None,
@@ -2101,6 +2167,12 @@ with gr.Blocks(title="AI Puppet Theater") as app:
             interactive=False,
             elem_classes=["transcript-box", "no-field-label"],
         )
+    with gr.Accordion("Agent State", open=False):
+        agent_state_output = gr.HTML(
+            value=EMPTY_AGENT_STATE,
+            label="Agent State",
+            elem_classes=["no-field-label"],
+        )
     with gr.Accordion("Behind the Curtain", open=False):
         director_output = gr.Textbox(
             value=EMPTY_DIRECTOR_LOG,
@@ -2181,6 +2253,7 @@ with gr.Blocks(title="AI Puppet Theater") as app:
             session_state,
             stage_output,
             transcript_output,
+            agent_state_output,
             director_output,
             trace_output,
             trace_download,
@@ -2200,6 +2273,7 @@ with gr.Blocks(title="AI Puppet Theater") as app:
             session_state,
             stage_output,
             transcript_output,
+            agent_state_output,
             director_output,
             trace_output,
             trace_download,
@@ -2220,6 +2294,7 @@ with gr.Blocks(title="AI Puppet Theater") as app:
             session_state,
             stage_output,
             transcript_output,
+            agent_state_output,
             director_output,
             trace_output,
             trace_download,
@@ -2240,6 +2315,7 @@ with gr.Blocks(title="AI Puppet Theater") as app:
             session_state,
             stage_output,
             transcript_output,
+            agent_state_output,
             director_output,
             trace_output,
             trace_download,
@@ -2260,6 +2336,7 @@ with gr.Blocks(title="AI Puppet Theater") as app:
             session_state,
             stage_output,
             transcript_output,
+            agent_state_output,
             director_output,
             trace_output,
             trace_download,
@@ -2279,6 +2356,7 @@ with gr.Blocks(title="AI Puppet Theater") as app:
             session_state,
             stage_output,
             transcript_output,
+            agent_state_output,
             director_output,
             trace_output,
             trace_download,
@@ -2299,6 +2377,7 @@ with gr.Blocks(title="AI Puppet Theater") as app:
             actor_input,
             stage_output,
             transcript_output,
+            agent_state_output,
             director_output,
             trace_output,
             trace_download,

puppet_theater/backends.py

@@ -372,10 +372,12 @@ def deterministic_actor_response(
     prop: str | None,
 ) -> ActorResponse:
     return ActorResponse(
+        intent=_intent_for_beat(decision.beat_type, prop),
         line=_line_for_beat(session, decision, speaker, prop),
         emotion=_emotion_for_beat(decision.beat_type),
         gesture=_gesture_for_beat(decision.beat_type),
         stage_effect=decision.stage_effect or _effect_for_beat(decision.beat_type),
+        memory_update=_memory_for_beat(session, decision, speaker, prop),
         tool_request=None,
     )
 
@@ -518,7 +520,7 @@ def warm_up_openbmb(
         if zerogpu.USE_ZEROGPU:
             backend._generate_text(
                 "Return only this JSON: "
-                '{"line":"Ready.","emotion":"ready","gesture":"wave","stage_effect":"spotlight","tool_request":null}'
+                '{"intent":"Confirm readiness.","line":"Ready.","emotion":"ready","gesture":"wave","stage_effect":"spotlight","memory_update":"Ready for the cue.","tool_request":null}'
             )
         else:
             backend._load()
@@ -571,6 +573,8 @@ def build_actor_line_prompt(
     recent_transcript = "\n".join(
         f"{beat.speaker}: {beat.line}" for beat in session.transcript[-3:]
     ) or "No lines yet."
+    recent_memory = "; ".join(speaker.recent_memory[-3:]) or "None"
+    held_props = ", ".join(speaker.held_props or ([speaker.held_prop] if speaker.held_prop else [])) or "none"
     prompt = ACTOR_LINE_PROMPT.format(
         show_title=session.show_title,
         premise=session.premise,
@@ -578,6 +582,12 @@ def build_actor_line_prompt(
         beat_type=decision.beat_type,
         speaker_name=speaker.name,
         speaker_goal=speaker.goal,
+        speaker_mood=speaker.mood,
+        speaker_current_goal=speaker.current_goal or speaker.goal,
+        speaker_goal_progress=speaker.goal_progress,
+        speaker_held_props=held_props,
+        speaker_secret_status=speaker.secret_status,
+        speaker_recent_memory=recent_memory,
         speaker_style=speaker.speaking_style,
         audience_action=session.latest_audience_action or "None",
         latest_prop=prop or session.latest_prop or "None",
@@ -587,7 +597,7 @@ def build_actor_line_prompt(
     )
     return (
         f"{prompt}\nRecent transcript:\n{recent_transcript}\n\n"
-        "Keep the line under 220 characters. Return JSON only."
+        "Keep the line under 25 words. Keep intent and memory_update short. Return JSON only."
     )
 
 
@@ -621,6 +631,7 @@ def parse_actor_output(raw_output: ActorResponse | dict[str, Any] | str) -> tupl
     if parsed is None:
         return None, "invalid_schema"
 
+    parsed, validation_status = _normalize_actor_payload(parsed)
     try:
         response = ActorResponse.model_validate(parsed)
     except ValidationError:
@@ -629,12 +640,13 @@ def parse_actor_output(raw_output: ActorResponse | dict[str, Any] | str) -> tupl
     if not response.line.strip():
         return None, "invalid_empty_line"
 
-    if len(response.line) > MAX_ACTOR_LINE_CHARS:
-        capped_line = response.line[: MAX_ACTOR_LINE_CHARS - 3].rstrip() + "..."
+    if len(response.line) > MAX_ACTOR_LINE_CHARS or len(response.line.split()) > 25:
+        capped_line = _cap_words(response.line, 25)
         response = response.model_copy(update={"line": capped_line})
-        return response, "valid_line_capped"
+        capped_status = "valid_line_capped"
+        return response, f"{validation_status};{capped_status}" if validation_status != "valid" else capped_status
 
-    return response, "valid"
+    return response, validation_status
 
 
 def _coerce_actor_output(raw_output: ActorResponse | dict[str, Any] | str) -> ActorResponse | dict[str, Any] | None:
@@ -646,6 +658,14 @@ def _coerce_actor_output(raw_output: ActorResponse | dict[str, Any] | str) -> Ac
         text = raw_output.strip()
         if not text:
             return None
+        if text.startswith("```"):
+            text = text.strip("`")
+            if "\n" in text:
+                text = text.split("\n", maxsplit=1)[1]
+        start = text.find("{")
+        end = text.rfind("}")
+        if start != -1 and end != -1 and end > start:
+            text = text[start : end + 1]
         try:
             decoded = json.loads(text)
         except json.JSONDecodeError:
@@ -654,6 +674,47 @@ def _coerce_actor_output(raw_output: ActorResponse | dict[str, Any] | str) -> Ac
     return None
 
 
+def _normalize_actor_payload(parsed: ActorResponse | dict[str, Any]) -> tuple[ActorResponse | dict[str, Any], str]:
+    if isinstance(parsed, ActorResponse):
+        return parsed, "valid"
+
+    normalized = dict(parsed)
+    notes: list[str] = []
+    if "intent" not in normalized:
+        normalized["intent"] = "Respond to the Director's cue."
+        notes.append("compat_intent_defaulted")
+    if "memory_update" not in normalized:
+        normalized["memory_update"] = ""
+        notes.append("compat_memory_defaulted")
+    if "tool_request" not in normalized:
+        normalized["tool_request"] = None
+        notes.append("compat_tool_defaulted")
+
+    if isinstance(normalized.get("line"), str):
+        line = " ".join(str(normalized["line"]).strip().split())
+        if len(line) > MAX_ACTOR_LINE_CHARS or len(line.split()) > 25:
+            normalized["line"] = _cap_words(line, 25)
+            notes.append("line_capped")
+    if isinstance(normalized.get("intent"), str) and len(str(normalized["intent"])) > 90:
+        normalized["intent"] = str(normalized["intent"])[:87].rstrip() + "..."
+        notes.append("intent_capped")
+    if isinstance(normalized.get("memory_update"), str) and len(str(normalized["memory_update"])) > 140:
+        normalized["memory_update"] = str(normalized["memory_update"])[:137].rstrip() + "..."
+        notes.append("memory_capped")
+
+    return normalized, ";".join(notes) if notes else "valid"
+
+
+def _cap_words(value: str, max_words: int) -> str:
+    words = " ".join(value.strip().split()).split()
+    capped = " ".join(words[:max_words]).rstrip(" ,;:")
+    if len(capped) > MAX_ACTOR_LINE_CHARS:
+        capped = capped[: MAX_ACTOR_LINE_CHARS - 3].rstrip()
+    if len(words) > max_words or len(value) > MAX_ACTOR_LINE_CHARS:
+        return f"{capped}..."
+    return capped
+
+
 def _elapsed_ms(start_time: float) -> int:
     return round((time.perf_counter() - start_time) * 1000)
 
@@ -720,10 +781,11 @@ def _line_for_beat(
     prop: str | None,
 ) -> str:
     if prop is not None:
-        return f"I shall use this {prop} as evidence, a prop, and possibly a tiny emotional support object."
+        return f"This {prop} is evidence, comfort, and possibly our smallest witness."
     beat_type = decision.beat_type
     if beat_type == "setup":
-        return f"I see it clearly: {session.premise}, and somehow I am in charge."
+        premise = _cap_words(session.premise, 12).rstrip(".")
+        return f"I see it clearly: {premise}, and somehow I am in charge."
     if beat_type == "denial_or_contradiction":
         return "Absolutely not. The premise is innocent, which is exactly what makes it suspicious."
     if beat_type == "evidence_or_prop":
@@ -737,6 +799,38 @@ def _line_for_beat(
     return "Curtain call! We solved nothing, learned everything, and bowed before the wobble got worse."
 
 
+def _intent_for_beat(beat_type: str, prop: str | None) -> str:
+    if prop is not None:
+        return f"Make the {prop} matter."
+    return {
+        "setup": "Establish the scene.",
+        "denial_or_contradiction": "Challenge the premise.",
+        "evidence_or_prop": "Turn a clue into momentum.",
+        "secret_reveal": "Reveal pressure without derailing.",
+        "chaos_or_intervention": "React and escalate briefly.",
+        "finale": "Close the show cleanly.",
+    }[beat_type]
+
+
+def _memory_for_beat(
+    session: TheaterSession,
+    decision: DirectorDecision,
+    speaker: Actor,
+    prop: str | None,
+) -> str:
+    if prop is not None:
+        return f"Used {prop} as important evidence."
+    if decision.beat_type == "secret_reveal":
+        if decision.reveal_secret:
+            return "Shared a secret with the audience."
+        return "Almost revealed a secret under pressure."
+    if decision.beat_type == "finale":
+        return "Reached the curtain call."
+    if session.latest_audience_action:
+        return "Reacted to the audience interruption."
+    return f"Advanced the {decision.beat_type.replace('_', ' ')} beat."
+
+
 def _emotion_for_beat(beat_type: str) -> str:
     return {
         "setup": "curious",

puppet_theater/director.py

@@ -459,13 +459,16 @@ def run_one_beat(session: TheaterSession | None) -> TheaterSession | None:
     response = backend_generation.response
     beat = Beat(
         speaker=speaker.name,
+        intent=response.intent,
         line=response.line,
         emotion=response.emotion,
         gesture=response.gesture,
         stage_effect=response.stage_effect or decision.stage_effect,
+        memory_update=response.memory_update,
         tool_request=response.tool_request,
     )
     session.transcript.append(beat)
+    state_update = apply_actor_state_update(session, speaker, response, decision, prop)
 
     if prop is not None:
         session.latest_prop = None
@@ -509,6 +512,35 @@ def run_one_beat(session: TheaterSession | None) -> TheaterSession | None:
         fallback_reason=backend_generation.error,
         load_status=backend_generation.load_status,
     )
+    add_trace_event(
+        session,
+        "actor_intent",
+        beat_index=session.beat_index,
+        speaker=speaker.name,
+        intent=_public_actor_text(response.intent, speaker),
+        validation_status=backend_generation.validation_status,
+        fallback_used=backend_generation.fallback_used,
+    )
+    if state_update["memory_update"]:
+        add_trace_event(
+            session,
+            "actor_memory_update",
+            beat_index=session.beat_index,
+            speaker=speaker.name,
+            memory_update=state_update["memory_update"],
+        )
+    add_trace_event(
+        session,
+        "actor_state_update",
+        beat_index=session.beat_index,
+        speaker=speaker.name,
+        mood=speaker.mood,
+        current_goal=_public_actor_text(speaker.current_goal or "", speaker),
+        goal_progress=_public_actor_text(speaker.goal_progress, speaker),
+        held_props=list(speaker.held_props),
+        secret_status=speaker.secret_status,
+        memory_count=len(speaker.recent_memory),
+    )
     if backend_generation.error:
         add_trace_event(
             session,
@@ -553,6 +585,40 @@ def _actor_by_name(session: TheaterSession, actor_name: str) -> Actor:
     return session.actors[session.beat_index % len(session.actors)]
 
 
+def apply_actor_state_update(
+    session: TheaterSession,
+    speaker: Actor,
+    response: object,
+    decision: DirectorDecision,
+    prop: str | None,
+) -> dict[str, str]:
+    intent = _short_public_text(getattr(response, "intent", "") or "Respond to the Director's cue.", speaker, 90)
+    memory_update = _short_public_text(getattr(response, "memory_update", "") or "", speaker, 140)
+    emotion = _short_public_text(getattr(response, "emotion", "") or "focused", speaker, 40)
+
+    speaker.mood = emotion
+    speaker.current_goal = intent
+    speaker.goal_progress = f"Beat {session.beat_index}: {intent}"
+
+    if prop is not None and prop not in speaker.held_props:
+        speaker.held_props.append(prop)
+    if prop is not None:
+        speaker.held_prop = prop
+
+    if decision.reveal_secret:
+        speaker.secret_status = "revealed"
+    elif decision.beat_type == "secret_reveal" and speaker.secret_status == "hidden":
+        speaker.secret_status = "hinted"
+    elif decision.beat_type == "finale" and speaker.secret_status in {"hinted", "revealed"}:
+        speaker.secret_status = "resolved"
+
+    if memory_update:
+        speaker.recent_memory.append(memory_update)
+        speaker.recent_memory = speaker.recent_memory[-4:]
+
+    return {"intent": intent, "memory_update": memory_update, "mood": emotion}
+
+
 def build_director_prompt(session: TheaterSession) -> str:
     actor_profiles = "\n".join(
         "- "
@@ -691,6 +757,20 @@ def _trace_text(value: str) -> str:
     return " ".join(value.split()).replace(":", "-")[:140]
 
 
+def _public_actor_text(value: str, actor: Actor) -> str:
+    text = " ".join(value.split())
+    if actor.secret and actor.secret_status not in {"revealed", "resolved"}:
+        text = text.replace(actor.secret, "[redacted secret]")
+    return text[:140]
+
+
+def _short_public_text(value: str, actor: Actor, max_chars: int) -> str:
+    text = _public_actor_text(value, actor)
+    if len(text) <= max_chars:
+        return text
+    return text[: max_chars - 3].rstrip() + "..."
+
+
 def _record_director_backend_status(backend: object, generation: DirectorGeneration) -> None:
     if hasattr(backend, "latest_latency_ms"):
         backend.latest_latency_ms = generation.latency_ms

puppet_theater/models.py

@@ -4,7 +4,7 @@ from uuid import uuid4
 
 from typing import Any, Literal
 
-from pydantic import BaseModel, Field, field_validator
+from pydantic import BaseModel, Field, ValidationInfo, field_validator
 
 
 BeatType = Literal[
@@ -18,20 +18,47 @@ BeatType = Literal[
 
 
 class ActorResponse(BaseModel):
+    intent: str = Field(default="Keep the scene moving.", description="Short visible actor intention.")
     line: str = Field(description="Short, stage-ready puppet dialogue.")
     emotion: str
     gesture: str
     stage_effect: str
+    memory_update: str = Field(default="", description="Short visible memory note from this beat.")
     tool_request: str | None = None
 
-    @field_validator("line", "emotion", "gesture", "stage_effect")
+    @field_validator("intent", "line", "emotion", "gesture", "stage_effect", "memory_update")
     @classmethod
-    def require_text(cls, value: str) -> str:
+    def require_text(cls, value: str, info: ValidationInfo) -> str:
         cleaned = " ".join(value.strip().split())
-        if not cleaned:
+        if not cleaned and info.field_name != "memory_update":
             raise ValueError("field must not be empty")
         return cleaned
 
+    @field_validator("intent")
+    @classmethod
+    def keep_intent_short(cls, value: str) -> str:
+        if len(value) > 90:
+            raise ValueError("intent must be 90 characters or fewer")
+        return value
+
+    @field_validator("line")
+    @classmethod
+    def keep_line_short(cls, value: str) -> str:
+        if not value:
+            raise ValueError("line must not be empty")
+        if len(value.split()) > 25:
+            raise ValueError("line must be 25 words or fewer")
+        if len(value) > 220:
+            raise ValueError("line must be 220 characters or fewer")
+        return value
+
+    @field_validator("memory_update")
+    @classmethod
+    def keep_memory_short(cls, value: str) -> str:
+        if len(value) > 140:
+            raise ValueError("memory_update must be 140 characters or fewer")
+        return value
+
     @field_validator("tool_request")
     @classmethod
     def clean_optional_text(cls, value: str | None) -> str | None:
@@ -76,15 +103,23 @@ class Actor:
     speaking_style: str
     tools: list[str] = field(default_factory=list)
     held_prop: str | None = None
+    mood: str = "ready"
+    current_goal: str | None = None
+    goal_progress: str = "Waiting for the curtain."
+    held_props: list[str] = field(default_factory=list)
+    secret_status: Literal["hidden", "hinted", "revealed", "resolved"] = "hidden"
+    recent_memory: list[str] = field(default_factory=list)
 
 
 @dataclass
 class Beat:
     speaker: str
+    intent: str
     line: str
     emotion: str
     gesture: str
     stage_effect: str
+    memory_update: str = ""
     tool_request: str | None = None
 
 

puppet_theater/prompts.py

@@ -1,18 +1,28 @@
 ACTOR_LINE_PROMPT = """You are writing one short puppet line for AI Puppet Theater.
 
 Return only JSON with these fields:
+- intent: one short visible reason for the actor's next move
 - line: a short, stage-ready spoken line
 - emotion: one concise emotion label
 - gesture: one concise stage gesture label
 - stage_effect: one concise stage effect label
+- memory_update: one short visible note the actor should remember, or empty string
 - tool_request: null or one concise theatrical tool request
 
+Keep line under 25 words. Return JSON only.
+
 Show title: {show_title}
 Premise: {premise}
 Setting: {setting}
 Beat type: {beat_type}
 Speaker: {speaker_name}
 Speaker goal: {speaker_goal}
+Speaker mood: {speaker_mood}
+Speaker current goal: {speaker_current_goal}
+Speaker goal progress: {speaker_goal_progress}
+Speaker held props: {speaker_held_props}
+Speaker secret status: {speaker_secret_status}
+Speaker recent memory: {speaker_recent_memory}
 Speaker style: {speaker_style}
 Director instruction: {director_instruction}
 Reveal secret this beat: {reveal_secret}

tests/test_director.py

@@ -5,10 +5,12 @@ from puppet_theater.director import (
     build_director_prompt,
     choose_director_decision,
     parse_director_decision,
+    run_one_beat,
     run_full_act,
     story_phase,
 )
 from puppet_theater.models import DirectorDecision
+from puppet_theater.backends import parse_actor_output
 from puppet_theater.session import create_show_from_premise, resolve_show_length
 
 
@@ -77,6 +79,40 @@ def test_invalid_llm_speaker_is_rejected() -> None:
     assert status == "invalid_speaker"
 
 
+def test_old_actor_output_defaults_agentic_fields() -> None:
+    response, status = parse_actor_output(
+        {
+            "line": "The moon denies everything with suspicious confidence.",
+            "emotion": "suspicious",
+            "gesture": "point_accusingly",
+            "stage_effect": "spotlight",
+            "tool_request": None,
+        }
+    )
+
+    assert response is not None
+    assert response.intent == "Respond to the Director's cue."
+    assert response.memory_update == ""
+    assert "compat_intent_defaulted" in status
+    assert "compat_memory_defaulted" in status
+
+
+def test_actor_state_updates_after_beat() -> None:
+    session = create_show_from_premise("A moon detective interrogates a suspicious toaster")
+    actor = session.actors[0]
+
+    run_one_beat(session)
+
+    assert session.transcript[-1].intent
+    assert actor.mood == session.transcript[-1].emotion
+    assert actor.current_goal == session.transcript[-1].intent
+    assert actor.recent_memory
+    event_types = {event["type"] for event in session.trace_events if isinstance(event, dict)}
+    assert "actor_intent" in event_types
+    assert "actor_memory_update" in event_types
+    assert "actor_state_update" in event_types
+
+
 def test_fallback_used_when_hf_api_director_cannot_run(monkeypatch) -> None:
     session = create_show_from_premise("A kitchen council debates a heroic toaster", director_mode="hf_api")
     monkeypatch.setattr(director_module, "get_backend", lambda *args, **kwargs: object())