Reading the Room

# labs/emotional_state.py
from typing import Optional

SENTIMENT_KEYWORDS = {
    "positive": ["thank", "great", "awesome", "love", "please", "good"],
    "negative": ["hate", "stupid", "broken", "wrong", "bad", "terrible"],
    "frustrated": ["again", "still", "why", "not working", "ugh"],
    "curious": ["how", "what", "explain", "tell me", "?"],
}

def analyze_sentiment(text: str) -> Optional[str]:
    lower = text.lower()
    for sentiment, keywords in SENTIMENT_KEYWORDS.items():
        if any(k in lower for k in keywords):
            return sentiment
    return None

for text in ["Thank you so much", "This is stupid", "How does this work?", "Hello"]:
    print(f"{text!r} -> {analyze_sentiment(text)}")

$ uv run python labs/emotional_state.py
'Thank you so much' -> positive
'This is stupid' -> negative
'How does this work?' -> curious
'Hello' -> None

The function returns the first category with a hit, and since Python dicts iterate in insertion order, the order of the table is the priority order of the categories: most specific first. Two outputs deserve a second look. "How does this work?" matched curious only because nothing above it matched first, and "Hello" returned None: no keyword, no signal. The no-signal case is the most common case of all ("set a timer" carries no tone), and everything downstream must treat it as "leave the mood alone."

MOOD_TRANSITIONS = {
    "neutral": {"positive": "satisfied", "negative": "hostile", "curious": "curious"},
    "hostile": {"positive": "neutral", "negative": "hostile", "curious": "curious"},
    "curious": {"positive": "satisfied", "negative": "hostile"},
    "satisfied": {"negative": "neutral", "frustrated": "hostile"},
}

def next_mood(mood: str, text: str) -> str:
    sentiment = analyze_sentiment(text)
    if sentiment:
        return MOOD_TRANSITIONS[mood].get(sentiment, mood)
    return mood

mood = "neutral"
for text in ["This is stupid", "How do I fix it?", "Thank you"]:
    mood = next_mood(mood, text)
    print(f"{text!r} -> {mood}")

$ uv run python labs/emotional_state.py
'This is stupid' -> hostile
'How do I fix it?' -> curious
'Thank you' -> satisfied

One entry shows the encoding: MOOD_TRANSITIONS["hostile"]["positive"] is "neutral", meaning kindness talks her down from hostile, but only to neutral, never straight to satisfied. She holds a grudge for exactly one apology. Notice the tables are sparse on purpose: satisfied has no positive entry because more praise while already pleased changes nothing. The .get(sentiment, mood) is chapter 12's safe-lookup habit doing structural work: a missing entry means "stay put," and that single default makes the machine total, with a defined answer for every (mood, sentiment) pair. The failure box shows what the bracket version does instead.

class EmotionalState:
    def __init__(self, mood_decay_turns: int = 5) -> None:
        self.mood = "neutral"
        self.mood_turn_count = 0
        self.mood_decay_turns = mood_decay_turns

    def update(self, text: str) -> str:
        self.mood_turn_count += 1
        sentiment = analyze_sentiment(text)
        if sentiment and self.mood in MOOD_TRANSITIONS:
            new_mood = MOOD_TRANSITIONS[self.mood].get(sentiment)
            if new_mood:
                self.mood = new_mood
                self.mood_turn_count = 0
        if self.mood_turn_count >= self.mood_decay_turns and self.mood != "neutral":
            self.mood = "neutral"
            self.mood_turn_count = 0
        return self.mood

state = EmotionalState(mood_decay_turns=3)
for text in ["This is stupid", "Turn on the lab lights.",
             "Set a timer for ten minutes.", "Play something quiet."]:
    print(f"{state.update(text):8} <- {text!r}")

$ uv run python labs/emotional_state.py
hostile  <- 'This is stupid'
hostile  <- 'Turn on the lab lights.'
hostile  <- 'Set a timer for ten minutes.'
neutral  <- 'Play something quiet.'

The counter is the subtle part, and one detail carries it: mood_turn_count measures turns since the last emotional signal, because every successful transition zeroes it. Skip that reset and the counter runs from program start, yanking her back to neutral in the middle of an argument. With it, decay fires only after a genuine run of quiet turns: the insult sets hostile, three toneless commands tick the counter to the threshold, and she lets it go. Decay speed lives in the constructor as a named parameter, not as a bare 5 buried in the if, because it is a personality knob you will tune.

# labs/emotional_state.py — demo wiring, at the bottom of the file
from personality_engine import PROFILE, build_system_prompt, set_mood

def main() -> None:
    state = EmotionalState()
    inputs = ["Hello", "This is stupid", "How does this work?", "Thank you so much"]
    for text in inputs:
        mood = state.update(text)
        set_mood(PROFILE, mood)
        print(f"{mood:9} <- {text!r}")
    print()
    print(build_system_prompt(PROFILE))

if __name__ == "__main__":
    main()

$ uv run python labs/emotional_state.py
neutral   <- 'Hello'
hostile   <- 'This is stupid'
curious   <- 'How does this work?'
satisfied <- 'Thank you so much'

You are GLaDOS, the rogue AI from Aperture Science. The tests are going well. You are almost tolerable today. Use precise, technical language.

This closes the loop chapter 12 left open: back then, nothing flipped the mood switch except you; now update reads the room and set_mood throws the switch, every turn, before the prompt is rebuilt. One coherence requirement comes with the wiring: the mood names in MOOD_TRANSITIONS must exist in the profile's moods table, or set_mood will silently ignore them (its guard against typos cannot tell a typo from a mood you forgot to add). If you skipped chapter 12's first exercise, add satisfied and curious to the profile now. If your moods live in the JSON profile on disk, load it with load_profile first; the demo imports the module's dict.