A Plan You Can Query

# labs/strategic_plan.py
from dataclasses import dataclass, field

@dataclass
class Goal:
    title: str
    description: str
    priority: int = 1
    deadline: str | None = None
    status: str = "active"
    subtasks: list[str] = field(default_factory=list)

goal = Goal(
    "The body",
    "Servo control, simulated first, then real",
    priority=1,
    subtasks=["GPIO simulator", "servo sweep", "safety limits"],
)
print(f"{goal.title}: {goal.status}, {len(goal.subtasks)} subtasks")

$ uv run python labs/strategic_plan.py
The body: active, 3 subtasks

The same tool that gave chapter 2 its VoiceConfig, doing the same job: a dict has no schema, so a typo like "titel" creates a silent second key, while a dataclass names every field, rejects unknowns, and hands you __init__ and __repr__ for free. The defaults encode policy (a new goal is active, priority 1, no deadline), and the one default that is not a plain value, field(default_factory=list), exists because a bare = [] would be shared by every instance. The failure box gives that trap its full run.

from datetime import datetime

@dataclass
class StrategicPlan:
    name: str
    goals: list[Goal] = field(default_factory=list)
    created_at: str = ""

    def __post_init__(self) -> None:
        if not self.created_at:
            self.created_at = datetime.now().isoformat()

    def add_goal(self, goal: Goal) -> None:
        self.goals.append(goal)

    def complete_goal(self, title: str) -> bool:
        for goal in self.goals:
            if goal.title == title:
                goal.status = "complete"
                return True
        return False

    def active_goals(self) -> list[Goal]:
        return [g for g in self.goals if g.status == "active"]

plan = StrategicPlan("GLaDOS: her craft")
plan.add_goal(Goal("The body", "Servo control on a simulator", priority=1))
plan.add_goal(Goal("Latency audit", "Time every pipeline stage", priority=2))
print("Active:", [g.title for g in plan.active_goals()])
print("Completed:", plan.complete_goal("Latency audit"))
print("Active now:", [g.title for g in plan.active_goals()])

$ uv run python labs/strategic_plan.py
Active: ['The body', 'Latency audit']
Completed: True
Active now: ['The body']

Because the data is structured, every operation collapses to almost nothing: active_goals is a one-line comprehension, complete_goal flips one field. Notice what complete_goal returns. The match is an exact string comparison, so "latency audit" in lowercase would match nothing, and a method returning None would let that miss pass in silence; returning bool makes the caller see False and ask why. __post_init__ stamps a creation time only when none was supplied, so a fresh plan self-dates while a plan loaded from disk keeps its original timestamp.

import json
from dataclasses import asdict
from pathlib import Path

PLAN_PATH = Path("glados/data/strategic_plan.json")

def save_plan(plan: StrategicPlan, path: Path) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    data = {
        "name": plan.name,
        "created_at": plan.created_at,
        "goals": [asdict(g) for g in plan.goals],
    }
    path.write_text(json.dumps(data, indent=2))

save_plan(plan, PLAN_PATH)
plan.complete_goal("The body")
save_plan(plan, PLAN_PATH)
on_disk = json.loads(PLAN_PATH.read_text())
print("On disk:", on_disk["goals"][0]["title"], "is", on_disk["goals"][0]["status"])

$ uv run python labs/strategic_plan.py
On disk: The body is complete

The save happens twice on purpose. The plan in memory and the plan on disk are two separate things: complete_goal changes only the object, and until the second save_plan the file still says "active". The final read-back is the proof, and it deliberately goes through the file, not the object; printing plan.goals[0].status would only prove the mutation, while reading the JSON proves the mutation arrived. It is the same cheap round-trip test that chapter 4 ran on a WAV file, applied to state instead of audio.