Add lifecycle, divorce, elections, memory query, baby agents, hospital births

Major simulation features:
- Age progression (1 year per 365 sim days) with lifecycle stages
- Death system for 80+ with exponential probability curve
- Divorce mechanic for unhappy marriages (low trust/sentiment/mood)
- Married couples move in together (cohabitation)
- Church wedding ceremonies, hospital births after 9 sim-day pregnancy
- Baby agents born as real citizens, living with parents, autonomous at age 4
- Annual mayor elections with weighted voting (18+ citizens)
- Short-term (weekly) and long-term goals with auto-refresh
- Memory query API: ask any agent about their memories via LLM
- Community score tracking for election candidacy
- UI: lifecycle badges, deceased agents, mayor display, split goals,
memory query input, parent info, new event icons

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

src/soci/agents/agent.py

@@ -79,7 +79,7 @@ class Agent:
 
         # Life history — append-only timeline of significant events
         self.life_events: list[dict] = []
-        # Personal goals — evolving aspirations
+        # Personal goals — evolving aspirations (each has "term": "short" or "long")
         self.goals: list[dict] = []
         self._next_goal_id: int = 0
         # Pregnancy (female agents)
@@ -89,6 +89,23 @@ class Agent:
         # Children (name strings)
         self.children: list[str] = []
 
+        # Age progression — tracks starting age and the day it was set
+        self._birth_age: int = persona.age  # Age when simulation started
+        self._birth_day: int = 0            # Sim day when agent was created
+        # Alive status
+        self.alive: bool = True
+        self.death_day: int = 0
+        self.death_cause: str = ""
+        # Parent agent IDs (for baby agents)
+        self.parent_ids: list[str] = []
+        # Lifecycle stage
+        self.lifecycle_stage: str = self._compute_lifecycle_stage()
+        # Mayor status
+        self.is_mayor: bool = False
+        self.mayor_term_start_day: int = 0
+        # Community contribution score (for election)
+        self.community_score: float = 0.0
+
     @property
     def is_busy(self) -> bool:
         return self._action_ticks_remaining > 0
@@ -207,15 +224,76 @@ class Agent:
         """Reset plan flag for a new day."""
         self._has_plan_today = False
 
+    def _compute_lifecycle_stage(self) -> str:
+        """Compute lifecycle stage from current age."""
+        age = self.persona.age
+        if age < 4:
+            return "infant"
+        elif age < 6:
+            return "toddler"
+        elif age < 12:
+            return "child"
+        elif age < 18:
+            return "teenager"
+        elif age < 30:
+            return "young_adult"
+        elif age < 60:
+            return "adult"
+        elif age < 75:
+            return "senior"
+        else:
+            return "elderly"
+
+    def get_current_age(self, current_day: int) -> int:
+        """Calculate agent's current age based on sim days elapsed.
+        Each 365 sim days = 1 year of age."""
+        days_elapsed = max(0, current_day - self._birth_day)
+        years_elapsed = days_elapsed // 365
+        return self._birth_age + years_elapsed
+
+    def tick_age(self, current_day: int) -> bool:
+        """Update age based on current sim day. Returns True if age changed."""
+        new_age = self.get_current_age(current_day)
+        if new_age != self.persona.age:
+            self.persona.age = new_age
+            self.lifecycle_stage = self._compute_lifecycle_stage()
+            return True
+        return False
+
+    def check_death(self, current_day: int) -> bool:
+        """Check if this agent should die of old age. Only agents 80+ have a chance."""
+        import random
+        if not self.alive or self.persona.age < 80:
+            return False
+        # Gentle curve: agents live a few years past 80 on average
+        # 80 = 0.05%/day (~17% annual), 90 = 0.2%/day (~52% annual),
+        # 100 = 0.5%/day (~84% annual), 110 = 1%/day (~97% annual)
+        age = self.persona.age
+        daily_death_chance = 0.0005 * (1.08 ** (age - 80))  # exponential growth
+        return random.random() < daily_death_chance
+
+    def die(self, day: int, tick: int, cause: str = "old age") -> None:
+        """Mark agent as dead."""
+        self.alive = False
+        self.death_day = day
+        self.death_cause = cause
+        self.state = AgentState.IDLE
+        self.current_action = None
+        self._action_ticks_remaining = 0
+        self.add_life_event(day, tick, "death", f"Passed away from {cause} at age {self.persona.age}")
+
     def add_life_event(self, day: int, tick: int, event_type: str, description: str) -> dict:
         """Record a significant life event (promotion, marriage, birth, etc.)."""
         event = {"day": day, "tick": tick, "type": event_type, "description": description}
         self.life_events.append(event)
         return event
 
-    def add_goal(self, description: str, status: str = "active") -> dict:
-        """Add a personal goal."""
-        goal = {"id": self._next_goal_id, "description": description, "status": status, "progress": 0.0}
+    def add_goal(self, description: str, status: str = "active", term: str = "long") -> dict:
+        """Add a personal goal. term: 'short' (day/week) or 'long' (life goal)."""
+        goal = {
+            "id": self._next_goal_id, "description": description,
+            "status": status, "progress": 0.0, "term": term,
+        }
         self._next_goal_id += 1
         self.goals.append(goal)
         return goal
@@ -233,21 +311,35 @@ class Agent:
     def seed_biography(self, day: int, tick: int) -> None:
         """Generate initial life events from persona background. Called on sim reset."""
         p = self.persona
+        self._birth_day = day  # Track when agent entered the sim
         # Origin event
-        self.add_life_event(0, 0, "origin", f"Born and raised. {p.background}")
+        self.add_life_event(day, tick, "origin", f"Born and raised. {p.background}")
         # Career event
         if p.occupation and p.occupation.lower() not in ("newcomer", "unknown", "unemployed"):
-            self.add_life_event(0, 0, "career", f"Works as {p.occupation}")
-        # Seed initial goals based on persona
+            self.add_life_event(day, tick, "career", f"Works as {p.occupation}")
+        # Seed initial LONG-TERM goals based on persona
         occ_lower = (p.occupation or "").lower()
         if "student" in occ_lower:
-            self.add_goal("Graduate and find a career")
+            self.add_goal("Graduate and find a career", term="long")
         elif p.age < 30:
-            self.add_goal("Advance in my career")
+            self.add_goal("Advance in my career", term="long")
         if p.age >= 20 and p.age < 40:
-            self.add_goal("Find meaningful relationships")
+            self.add_goal("Find meaningful relationships", term="long")
         if p.age >= 30:
-            self.add_goal("Build a stable and happy life")
+            self.add_goal("Build a stable and happy life", term="long")
+        # Seed initial SHORT-TERM goals
+        if p.age >= 18:
+            self.add_goal("Meet someone new this week", term="short")
+        # Baby/child lifecycle goals
+        if p.age < 4:
+            self.lifecycle_stage = "infant"
+        elif p.age < 6:
+            self.add_goal("Go to kindergarten", term="long")
+        elif p.age < 12:
+            self.add_goal("Do well in school", term="long")
+        elif p.age < 18:
+            self.add_goal("Graduate high school", term="long")
+            self.add_goal("Figure out what to do after school", term="long")
 
     def biography_summary(self) -> str:
         """Short biography string for LLM context."""
@@ -279,9 +371,17 @@ class Agent:
             parts.append("I am currently pregnant.")
             parts.append("")
         active_goals = [g for g in self.goals if g["status"] == "active"]
-        if active_goals:
-            parts.append("MY GOALS:")
-            for g in active_goals:
+        long_goals = [g for g in active_goals if g.get("term") == "long"]
+        short_goals = [g for g in active_goals if g.get("term") == "short"]
+        if long_goals:
+            parts.append("MY LONG-TERM GOALS:")
+            for g in long_goals:
+                pct = int(g.get("progress", 0) * 100)
+                parts.append(f"- {g['description']} ({pct}% progress)")
+            parts.append("")
+        if short_goals:
+            parts.append("MY SHORT-TERM GOALS (this week):")
+            for g in short_goals:
                 pct = int(g.get("progress", 0) * 100)
                 parts.append(f"- {g['description']} ({pct}% progress)")
             parts.append("")
@@ -331,6 +431,16 @@ class Agent:
             "pregnancy_start_tick": self.pregnancy_start_tick,
             "pregnancy_partner_id": self.pregnancy_partner_id,
             "children": self.children,
+            "_birth_age": self._birth_age,
+            "_birth_day": self._birth_day,
+            "alive": self.alive,
+            "death_day": self.death_day,
+            "death_cause": self.death_cause,
+            "parent_ids": self.parent_ids,
+            "lifecycle_stage": self.lifecycle_stage,
+            "is_mayor": self.is_mayor,
+            "mayor_term_start_day": self.mayor_term_start_day,
+            "community_score": self.community_score,
         }
 
     @classmethod
@@ -358,4 +468,14 @@ class Agent:
         agent.pregnancy_start_tick = data.get("pregnancy_start_tick", 0)
         agent.pregnancy_partner_id = data.get("pregnancy_partner_id")
         agent.children = data.get("children", [])
+        agent._birth_age = data.get("_birth_age", agent.persona.age)
+        agent._birth_day = data.get("_birth_day", 0)
+        agent.alive = data.get("alive", True)
+        agent.death_day = data.get("death_day", 0)
+        agent.death_cause = data.get("death_cause", "")
+        agent.parent_ids = data.get("parent_ids", [])
+        agent.lifecycle_stage = data.get("lifecycle_stage", agent._compute_lifecycle_stage())
+        agent.is_mayor = data.get("is_mayor", False)
+        agent.mayor_term_start_day = data.get("mayor_term_start_day", 0)
+        agent.community_score = data.get("community_score", 0.0)
         return agent

src/soci/api/routes.py

@@ -212,6 +212,16 @@ async def get_agent(agent_id: str):
         "goals": agent.goals,
         "pregnant": agent.pregnant,
         "children": agent.children,
+        "alive": agent.alive,
+        "death_day": agent.death_day,
+        "death_cause": agent.death_cause,
+        "lifecycle_stage": agent.lifecycle_stage,
+        "parent_ids": agent.parent_ids,
+        "parent_names": [
+            sim.agents[pid].name for pid in agent.parent_ids if pid in sim.agents
+        ],
+        "is_mayor": agent.is_mayor,
+        "community_score": round(agent.community_score, 1),
     }
 
 
@@ -237,6 +247,71 @@ async def get_agent_memories(agent_id: str, limit: int = 20):
     ]
 
 
+class MemoryQueryRequest(BaseModel):
+    question: str
+
+
+@router.post("/agents/{agent_id}/ask")
+async def ask_agent_memory(agent_id: str, request: MemoryQueryRequest):
+    """Ask an agent about their memories using LLM. The agent reflects on their
+    experiences and answers the question in character."""
+    from soci.api.server import get_simulation
+    sim = get_simulation()
+    agent = sim.agents.get(agent_id)
+    if not agent:
+        raise HTTPException(status_code=404, detail=f"Agent {agent_id} not found")
+
+    # Gather relevant memories by searching for keywords in the question
+    all_memories = agent.memory.memories
+    question_lower = request.question.lower()
+
+    # Score memories by relevance to the question
+    scored = []
+    for m in all_memories:
+        score = m.importance
+        content_lower = m.content.lower()
+        # Boost if question keywords appear in memory
+        for word in question_lower.split():
+            if len(word) > 3 and word in content_lower:
+                score += 5
+        scored.append((score, m))
+    scored.sort(key=lambda x: x[0], reverse=True)
+    relevant = scored[:20]
+
+    memories_text = "\n".join(
+        f"- [Day {m.day} {m.time_str}] {m.content}" for _, m in relevant
+    )
+
+    # Also include life events
+    life_events_text = "\n".join(
+        f"- Day {e['day']}: {e['description']}" for e in agent.life_events[-15:]
+    )
+
+    # Build prompt
+    prompt = (
+        f"A person is asking you to reflect on your memories and life experiences.\n\n"
+        f"QUESTION: {request.question}\n\n"
+        f"YOUR RELEVANT MEMORIES:\n{memories_text}\n\n"
+        f"YOUR LIFE HISTORY:\n{life_events_text}\n\n"
+        f"Answer the question thoughtfully and in character, drawing on your actual "
+        f"memories and experiences. Be personal and emotional. If you don't have "
+        f"relevant memories, say so honestly."
+    )
+
+    try:
+        from soci.engine.llm import MODEL_HAIKU
+        response = await sim.llm.complete(
+            system=agent.persona.system_prompt(),
+            user_message=prompt,
+            model=MODEL_HAIKU,
+            temperature=0.8,
+            max_tokens=512,
+        )
+        return {"answer": response or "(no response)", "memories_used": len(relevant)}
+    except Exception as e:
+        return {"answer": f"(Could not generate response: {str(e)})", "memories_used": 0}
+
+
 @router.get("/conversations")
 async def get_conversations(include_history: bool = True, limit: int = 20):
     """Get active and recent conversations with full dialogue."""

src/soci/engine/simulation.py

@@ -199,6 +199,10 @@ class Simulation:
         routine_actions: list[tuple[Agent, AgentAction]] = []
 
         for agent in ordered_agents:
+            # Skip dead agents and infants (under 4 — no autonomous behavior)
+            if not agent.alive or agent.persona.age < 4:
+                continue
+
             # Tick needs
             is_sleeping = agent.state.value == "sleeping"
             agent.tick_needs(is_sleeping=is_sleeping)
@@ -344,6 +348,26 @@ class Simulation:
         # 9b. Pregnancy — check for new pregnancies and births
         self._tick_pregnancy()
 
+        # 9c. Age progression — once per sim day at midnight
+        if self.clock.hour == 0 and self.clock.minute == 0:
+            self._tick_aging()
+
+        # 9d. Divorce — check for unhappy marriages
+        if self.clock.hour == 12 and self.clock.minute == 0:
+            self._tick_divorce()
+
+        # 9e. Cohabitation — married couples move in together
+        if self.clock.hour == 8 and self.clock.minute == 0:
+            self._tick_cohabitation()
+
+        # 9f. Mayor election — every 365 days
+        if self.clock.day > 0 and self.clock.day % 365 == 0 and self.clock.hour == 10 and self.clock.minute == 0:
+            self._tick_election()
+
+        # 9g. Short-term goal refresh — weekly
+        if self.clock.day > 0 and self.clock.day % 7 == 0 and self.clock.hour == 6 and self.clock.minute == 0:
+            self._tick_short_term_goals()
+
         # 10. Advance clock
         self.clock.tick()
 
@@ -618,6 +642,12 @@ class Simulation:
         if len(self.conversation_history) > self._max_conversation_history:
             self.conversation_history = self.conversation_history[-self._max_conversation_history:]
 
+        # Boost community score for social interaction
+        for agent_id in conv.participants:
+            agent = self.agents.get(agent_id)
+            if agent and agent.alive:
+                agent.community_score += 0.5
+
         self._emit(
             f"  [CONV END] Conversation about '{conv.topic}' between "
             f"{', '.join(self.agents[p].name for p in conv.participants if p in self.agents)} ended."
@@ -758,6 +788,8 @@ class Simulation:
         agents_list = list(self.agents.values())
 
         for agent in agents_list:
+            if not agent.alive or agent.persona.age < 16:
+                continue
             loc = self.city.get_location(agent.location)
             if not loc:
                 continue
@@ -860,21 +892,33 @@ class Simulation:
                     if other_rel and other_rel.romantic_interest > 0.8:
                         rel.relationship_status = "married"
                         other_rel.relationship_status = "married"
-                        self._emit(f"  [ROMANCE] {agent.name} and {other.name} got married!")
+                        # Move both to church for the ceremony
+                        church = self.city.get_location("church")
+                        if church:
+                            for a in [agent, other]:
+                                old_loc = self.city.get_location(a.location)
+                                if old_loc and a.location != "church":
+                                    old_loc.remove_occupant(a.id)
+                                    church.add_occupant(a.id)
+                                    a.location = "church"
+                        self._emit(f"  [ROMANCE] {agent.name} and {other.name} got married at the church!")
                         for a, o in [(agent, other), (other, agent)]:
                             a.add_observation(
                                 tick=self.clock.total_ticks, day=self.clock.day,
                                 time_str=self.clock.time_str,
-                                content=f"I married {o.name} today. I couldn't be happier.",
+                                content=f"I married {o.name} today at the church. I couldn't be happier.",
                                 importance=10, involved_agents=[o.id],
                             )
                             a.add_life_event(self.clock.day, self.clock.total_ticks,
-                                             "married", f"Married {o.name}")
+                                             "married", f"Married {o.name} at St. Mary's Church")
+                            # Boost community score for getting married
+                            a.community_score += 5.0
 
     def _tick_pregnancy(self) -> None:
-        """Handle pregnancy for married couples. Children are born after ~7 sim-days."""
+        """Handle pregnancy for married couples. Children are born at the hospital after ~9 sim-months."""
         import random as _rand
-        PREGNANCY_DURATION_TICKS = 672  # ~7 days (96 ticks/day at 15-min intervals)
+        # 9 sim-months: 9 * 30 days * 96 ticks/day = 25920, but compressed to ~9 sim-days
+        PREGNANCY_DURATION_TICKS = 864  # ~9 days (96 ticks/day × 9 days)
 
         for agent in list(self.agents.values()):
             # New pregnancy chance: married female, at home with partner
@@ -906,9 +950,25 @@ class Simulation:
                         a.mood = min(1.0, a.mood + 0.4)
                     self._emit(f"  [LIFE] {agent.name} and {partner.name} are expecting!")
 
-            # Birth check
+            # Move to hospital when close to due date (~1 day before)
             if agent.pregnant:
                 elapsed = self.clock.total_ticks - agent.pregnancy_start_tick
+                if elapsed >= (PREGNANCY_DURATION_TICKS - 96) and agent.location != "hospital":
+                    hospital = self.city.get_location("hospital")
+                    if hospital:
+                        old_loc = self.city.get_location(agent.location)
+                        if old_loc:
+                            old_loc.remove_occupant(agent.id)
+                        hospital.add_occupant(agent.id)
+                        agent.location = "hospital"
+                        agent.add_observation(
+                            tick=self.clock.total_ticks, day=self.clock.day,
+                            time_str=self.clock.time_str,
+                            content="Going to the hospital — the baby is coming soon!",
+                            importance=8,
+                        )
+                        self._emit(f"  [LIFE] {agent.name} went to the hospital for delivery!")
+
                 if elapsed >= PREGNANCY_DURATION_TICKS:
                     partner = self.agents.get(agent.pregnancy_partner_id)
                     # Pick a baby name
@@ -917,41 +977,343 @@ class Simulation:
                     baby_names_f = ["Emma", "Olivia", "Sophia", "Mia", "Isabella", "Zoe", "Luna", "Aria"]
                     is_girl = _r.random() < 0.5
                     pool = baby_names_f if is_girl else baby_names_m
-                    # Avoid duplicate names
-                    used = set(agent.children)
+                    # Avoid duplicate names across all agents
+                    used = set(agent.children) | {a.name.split()[-1] for a in self.agents.values()}
                     available = [n for n in pool if n not in used]
                     baby_name = _r.choice(available) if available else _r.choice(pool)
+                    # Surname from mother
+                    surname = agent.name.split()[-1] if " " in agent.name else ""
+                    full_baby_name = f"{baby_name} {surname}".strip()
 
                     agent.pregnant = False
-                    agent.children.append(baby_name)
+                    agent.children.append(full_baby_name)
                     agent.add_life_event(self.clock.day, self.clock.total_ticks,
-                                         "child_born", f"Gave birth to {baby_name}!")
+                                         "child_born", f"Gave birth to {full_baby_name}!")
                     agent.add_observation(
                         tick=self.clock.total_ticks, day=self.clock.day,
                         time_str=self.clock.time_str,
-                        content=f"Our baby {baby_name} was born today! I'm overwhelmed with joy.",
+                        content=f"Our baby {full_baby_name} was born today! I'm overwhelmed with joy.",
                         importance=10,
                     )
                     if partner:
-                        partner.children.append(baby_name)
+                        partner.children.append(full_baby_name)
                         partner.add_life_event(self.clock.day, self.clock.total_ticks,
-                                               "child_born", f"{agent.name} and I welcomed {baby_name}!")
+                                               "child_born", f"{agent.name} and I welcomed {full_baby_name}!")
                         partner.add_observation(
                             tick=self.clock.total_ticks, day=self.clock.day,
                             time_str=self.clock.time_str,
-                            content=f"Our baby {baby_name} was born! I'm a parent now!",
+                            content=f"Our baby {full_baby_name} was born! I'm a parent now!",
                             importance=10,
                         )
                         partner.mood = min(1.0, partner.mood + 0.5)
                     agent.mood = min(1.0, agent.mood + 0.5)
-                    self._emit(f"  [LIFE] {agent.name} gave birth to {baby_name}!")
+                    self._emit(f"  [LIFE] {agent.name} gave birth to {full_baby_name}!")
+
+                    # Create actual baby agent living with parents
+                    baby_id = f"baby_{full_baby_name.lower().replace(' ', '_')}_{self.clock.total_ticks}"
+                    baby_gender = "female" if is_girl else "male"
+                    baby_persona = Persona(
+                        id=baby_id,
+                        name=full_baby_name,
+                        age=0,
+                        occupation="infant",
+                        gender=baby_gender,
+                        background=f"Born to {agent.name}" + (f" and {partner.name}" if partner else "") + " in Soci City.",
+                        home_location=agent.persona.home_location,
+                        work_location="",
+                        openness=_r.randint(3, 8),
+                        conscientiousness=_r.randint(3, 8),
+                        extraversion=_r.randint(3, 8),
+                        agreeableness=_r.randint(4, 9),
+                        neuroticism=_r.randint(2, 7),
+                    )
+                    baby_agent = Agent(baby_persona)
+                    baby_agent._birth_day = self.clock.day
+                    baby_agent._birth_age = 0
+                    baby_agent.parent_ids = [agent.id] + ([partner.id] if partner else [])
+                    baby_agent.lifecycle_stage = "infant"
+                    # Baby lives at parents' home, no memories until age 4
+                    self.add_agent(baby_agent)
+                    self._emit(f"  [LIFE] New citizen: {full_baby_name} born!")
+
+    def _tick_aging(self) -> None:
+        """Update ages for all agents. Check for death of elderly agents."""
+        for agent in list(self.agents.values()):
+            if not agent.alive:
+                continue
+            old_age = agent.persona.age
+            changed = agent.tick_age(self.clock.day)
+            if changed:
+                new_age = agent.persona.age
+                # Birthday event
+                agent.add_life_event(
+                    self.clock.day, self.clock.total_ticks,
+                    "birthday", f"Turned {new_age} years old",
+                )
+                agent.add_observation(
+                    tick=self.clock.total_ticks, day=self.clock.day,
+                    time_str=self.clock.time_str,
+                    content=f"Today is my birthday! I'm now {new_age} years old.",
+                    importance=6,
+                )
+                self._emit(f"  [LIFE] {agent.name} turned {new_age}!")
+
+                # Lifecycle stage transitions with goal updates
+                if new_age == 4:
+                    agent.add_goal("Go to kindergarten", term="long")
+                    self._emit(f"  [LIFE] {agent.name} is old enough for kindergarten!")
+                elif new_age == 6:
+                    agent.add_goal("Do well in school", term="long")
+                elif new_age == 12:
+                    agent.add_goal("Graduate high school", term="long")
+                elif new_age == 18:
+                    agent.add_goal("Go to university", term="long")
+                    agent.add_goal("Get a job", term="long")
+                elif new_age == 22:
+                    agent.add_goal("Start a career", term="long")
+
+            # Death check for elderly
+            if agent.persona.age >= 80 and agent.check_death(self.clock.day):
+                agent.die(self.clock.day, self.clock.total_ticks)
+                self._emit(f"  [DEATH] {agent.name} passed away at age {agent.persona.age}.")
+                # Notify partner
+                if agent.partner_id and agent.partner_id in self.agents:
+                    partner = self.agents[agent.partner_id]
+                    partner.partner_id = None
+                    partner.mood = max(-1.0, partner.mood - 0.6)
+                    partner.add_life_event(
+                        self.clock.day, self.clock.total_ticks,
+                        "bereavement", f"Lost my partner {agent.name}",
+                    )
+                    partner.add_observation(
+                        tick=self.clock.total_ticks, day=self.clock.day,
+                        time_str=self.clock.time_str,
+                        content=f"My partner {agent.name} passed away. I'm devastated.",
+                        importance=10, involved_agents=[agent.id],
+                    )
+                # Remove from city location
+                loc = self.city.get_location(agent.location)
+                if loc:
+                    loc.remove_occupant(agent.id)
+
+    def _tick_divorce(self) -> None:
+        """Check for unhappy marriages that lead to divorce."""
+        for agent in list(self.agents.values()):
+            if not agent.alive or not agent.partner_id:
+                continue
+            partner = self.agents.get(agent.partner_id)
+            if not partner or not partner.alive:
+                continue
+            rel = agent.relationships.get(partner.id)
+            if not rel or rel.relationship_status != "married":
+                continue
+            # Divorce conditions: very low sentiment + trust + mood for extended period
+            if (rel.sentiment < 0.2 and rel.trust < 0.25
+                    and agent.mood < -0.3
+                    and random.random() < 0.01):  # 1% daily chance when unhappy
+                # Divorce!
+                rel.relationship_status = "divorced"
+                rel.romantic_interest = max(0, rel.romantic_interest - 0.5)
+                other_rel = partner.relationships.get(agent.id)
+                if other_rel:
+                    other_rel.relationship_status = "divorced"
+                    other_rel.romantic_interest = max(0, other_rel.romantic_interest - 0.5)
+                agent.partner_id = None
+                partner.partner_id = None
+                for a, o in [(agent, partner), (partner, agent)]:
+                    a.add_life_event(
+                        self.clock.day, self.clock.total_ticks,
+                        "divorce", f"Divorced {o.name}",
+                    )
+                    a.add_observation(
+                        tick=self.clock.total_ticks, day=self.clock.day,
+                        time_str=self.clock.time_str,
+                        content=f"I divorced {o.name}. Our marriage wasn't working anymore.",
+                        importance=9, involved_agents=[o.id],
+                    )
+                    a.mood = max(-1.0, a.mood - 0.4)
+                self._emit(f"  [ROMANCE] {agent.name} and {partner.name} got divorced!")
+
+    def _tick_cohabitation(self) -> None:
+        """Married couples move in together — move to one partner's home."""
+        processed = set()
+        for agent in list(self.agents.values()):
+            if not agent.alive or not agent.partner_id or agent.id in processed:
+                continue
+            partner = self.agents.get(agent.partner_id)
+            if not partner or not partner.alive or partner.id in processed:
+                continue
+            rel = agent.relationships.get(partner.id)
+            if not rel or rel.relationship_status != "married":
+                continue
+            # Already living together?
+            if agent.persona.home_location == partner.persona.home_location:
+                processed.add(agent.id)
+                processed.add(partner.id)
+                continue
+            # Move to the home of the agent who has lived there longer (or whichever is non-empty)
+            new_home = agent.persona.home_location
+            mover = partner
+            partner.persona.home_location = new_home
+            mover.add_life_event(
+                self.clock.day, self.clock.total_ticks,
+                "moved", f"Moved in with {agent.name} at {new_home}",
+            )
+            agent.add_observation(
+                tick=self.clock.total_ticks, day=self.clock.day,
+                time_str=self.clock.time_str,
+                content=f"{partner.name} moved in with me!",
+                importance=8, involved_agents=[partner.id],
+            )
+            self._emit(f"  [LIFE] {partner.name} moved in with {agent.name}")
+            processed.add(agent.id)
+            processed.add(partner.id)
+
+    def _tick_election(self) -> None:
+        """Annual mayor election — all citizens 18+ vote for the most community-oriented agent."""
+        eligible_voters = [
+            a for a in self.agents.values()
+            if a.alive and a.persona.age >= 18
+        ]
+        if len(eligible_voters) < 3:
+            return
+
+        # Candidates: all eligible non-player agents
+        candidates = [a for a in eligible_voters if not a.is_player]
+        if not candidates:
+            return
+
+        # Score candidates by community contribution:
+        # - interaction_count with diverse agents
+        # - agreeableness trait
+        # - community_score (accumulated from actions)
+        # - mood (positive people inspire)
+        scores: dict[str, float] = {}
+        for c in candidates:
+            score = 0.0
+            # Social connections
+            known = c.relationships.get_closest(20)
+            score += len(known) * 2.0
+            score += sum(r.sentiment for r in known) * 3.0
+            # Personality
+            score += c.persona.agreeableness * 1.5
+            score += c.persona.extraversion * 0.5
+            # Mood and contribution
+            score += max(0, c.mood) * 5.0
+            score += c.community_score
+            scores[c.id] = score
+
+        # Each voter votes — weighted random choice biased toward high scores
+        votes: dict[str, int] = {c.id: 0 for c in candidates}
+        for voter in eligible_voters:
+            # Bias toward people the voter knows and likes
+            voter_scores = {}
+            for c in candidates:
+                if c.id == voter.id:
+                    continue
+                base = scores.get(c.id, 0)
+                rel = voter.relationships.get(c.id)
+                if rel:
+                    base += rel.sentiment * 10 + rel.trust * 5
+                voter_scores[c.id] = max(0.1, base)
+            if not voter_scores:
+                continue
+            total = sum(voter_scores.values())
+            r = random.random() * total
+            cumulative = 0.0
+            chosen = list(voter_scores.keys())[0]
+            for cid, s in voter_scores.items():
+                cumulative += s
+                if r <= cumulative:
+                    chosen = cid
+                    break
+            votes[chosen] = votes.get(chosen, 0) + 1
+
+        # Winner
+        winner_id = max(votes, key=lambda k: votes[k])
+        winner = self.agents[winner_id]
+        vote_count = votes[winner_id]
+
+        # Remove old mayor
+        for a in self.agents.values():
+            if a.is_mayor:
+                a.is_mayor = False
+                a.add_life_event(
+                    self.clock.day, self.clock.total_ticks,
+                    "politics", "Term as Mayor ended",
+                )
+
+        # Set new mayor
+        winner.is_mayor = True
+        winner.mayor_term_start_day = self.clock.day
+        winner.add_life_event(
+            self.clock.day, self.clock.total_ticks,
+            "politics", f"Elected as Mayor of Soci City with {vote_count} votes!",
+        )
+        winner.add_observation(
+            tick=self.clock.total_ticks, day=self.clock.day,
+            time_str=self.clock.time_str,
+            content=f"I was elected Mayor of Soci City! {vote_count} people voted for me.",
+            importance=10,
+        )
+        winner.mood = min(1.0, winner.mood + 0.5)
+        self._emit(f"  [ELECTION] {winner.name} elected Mayor with {vote_count}/{len(eligible_voters)} votes!")
+
+        # All voters remember the election
+        for voter in eligible_voters:
+            if voter.id != winner_id:
+                voter.add_observation(
+                    tick=self.clock.total_ticks, day=self.clock.day,
+                    time_str=self.clock.time_str,
+                    content=f"{winner.name} was elected as our new Mayor.",
+                    importance=6, involved_agents=[winner_id],
+                )
+
+    def _tick_short_term_goals(self) -> None:
+        """Refresh short-term goals weekly — expire old ones, add new ones."""
+        import random as _r
+        short_goals_pool = [
+            "Meet someone new this week",
+            "Try a new restaurant",
+            "Exercise at least twice",
+            "Read something interesting",
+            "Help a neighbor",
+            "Visit the park",
+            "Have a deep conversation",
+            "Cook something special",
+            "Explore a new part of town",
+            "Catch up with an old friend",
+            "Organize my home",
+            "Learn something new",
+            "Spend time outdoors",
+            "Do something creative",
+        ]
+        for agent in self.agents.values():
+            if not agent.alive or agent.persona.age < 6:
+                continue
+            # Expire active short-term goals
+            for g in agent.goals:
+                if g.get("term") == "short" and g["status"] == "active":
+                    if g["progress"] >= 0.7:
+                        g["status"] = "completed"
+                        g["progress"] = 1.0
+                    else:
+                        g["status"] = "abandoned"
+            # Add 1-2 new short-term goals
+            count = _r.randint(1, 2)
+            for _ in range(count):
+                goal_desc = _r.choice(short_goals_pool)
+                agent.add_goal(goal_desc, term="short")
 
     def get_state_summary(self) -> dict:
         """Get a summary of the current simulation state."""
+        # Find current mayor
+        mayor = next((a for a in self.agents.values() if a.is_mayor and a.alive), None)
         return {
             "clock": self.clock.to_dict(),
             "weather": self.events.weather.value,
             "active_events": [e.to_dict() for e in self.events.active_events],
+            "mayor": {"id": mayor.id, "name": mayor.name} if mayor else None,
             "agents": {
                 aid: {
                     "name": a.name,
@@ -968,6 +1330,9 @@ class Simulation:
                     "is_player": a.is_player,
                     "pregnant": a.pregnant,
                     "children_count": len(a.children),
+                    "alive": a.alive,
+                    "lifecycle_stage": a.lifecycle_stage,
+                    "is_mayor": a.is_mayor,
                 }
                 for aid, a in self.agents.items()
             },

web/index.html

@@ -2732,22 +2732,30 @@ function showDefaultDetail() {
     return (a[1].name || '').localeCompare(b[1].name || '');
   });
 
+  const aliveCount = sorted.filter(([,a]) => a.alive !== false).length;
+  const deadCount = sorted.length - aliveCount;
+  const mayorInfo = window._mayorData ? `<div style="font-size:10px;color:#f0c040;margin:4px 0">\uD83C\uDFDB\uFE0F Mayor: ${esc(window._mayorData.name)}</div>` : '';
   el.innerHTML = `
-    <div class="section-header">Population (${Object.keys(agents).length})</div>
+    <div class="section-header">Population (${aliveCount} alive${deadCount > 0 ? `, ${deadCount} deceased` : ''})</div>
+    ${mayorInfo}
     ${sorted.map(([aid,a]) => {
-      const color = AGENT_COLORS[getAgentIdx(aid) % AGENT_COLORS.length];
-      const gi = a.gender==='female'?'\uD83D\uDC69':a.gender==='male'?'\uD83D\uDC68':'\uD83E\uDDD1';
-      const stateIcon = a.state==='in_conversation'?' \uD83D\uDCAC':(a.state==='sleeping'?' \uD83D\uDCA4':(a.state==='moving'?' \uD83D\uDEB6':''));
+      const isDead = a.alive === false;
+      const color = isDead ? '#555' : AGENT_COLORS[getAgentIdx(aid) % AGENT_COLORS.length];
+      const stg = a.lifecycle_stage || '';
+      const gi = isDead ? '\u2620\uFE0F' : (stg==='infant'||stg==='toddler') ? '\uD83D\uDC76' : (stg==='child'||stg==='teenager') ? '\uD83E\uDDD2' : a.gender==='female'?'\uD83D\uDC69':a.gender==='male'?'\uD83D\uDC68':'\uD83E\uDDD1';
+      const stateIcon = isDead ? '' : a.state==='in_conversation'?' \uD83D\uDCAC':(a.state==='sleeping'?' \uD83D\uDCA4':(a.state==='moving'?' \uD83D\uDEB6':''));
       const partner = a.partner_id && agents[a.partner_id] ? ` \u2764\uFE0F ${agents[a.partner_id].name.split(' ')[0]}` : '';
       const pregIcon = a.pregnant ? ' \uD83E\uDD30' : '';
       const kidIcon = a.children_count > 0 ? ` \uD83D\uDC76${a.children_count}` : '';
+      const mayorBadge = a.is_mayor ? ' \uD83C\uDFDB\uFE0F' : '';
+      const ageStr = a.age != null ? ` (${a.age})` : '';
       return `
-        <div class="agent-list-item" onclick="selectedAgentId='${aid}';fetchAgentDetail('${aid}');">
+        <div class="agent-list-item" onclick="selectedAgentId='${aid}';fetchAgentDetail('${aid}');" style="${isDead ? 'opacity:0.5' : ''}">
           <span class="agent-dot" style="background:${color}"></span>
           <span style="font-size:13px">${gi}</span>
           <div class="agent-info">
-            <div class="agent-name" style="color:${color}">${a.name}${partner}${pregIcon}${kidIcon}${stateIcon}</div>
-            <div class="agent-action">${esc(a.action||'idle')}</div>
+            <div class="agent-name" style="color:${color}">${a.name}${ageStr}${mayorBadge}${partner}${pregIcon}${kidIcon}${stateIcon}</div>
+            <div class="agent-action">${isDead ? 'Deceased' : esc(a.action||'idle')}</div>
           </div>
         </div>`;
     }).join('')}`;
@@ -2787,12 +2795,16 @@ function renderAgentDetail(data) {
     promotion:'\uD83D\uDCC8', graduated:'\uD83C\uDF93', achievement:'\u2B50',
     milestone:'\uD83C\uDFC6', new_job:'\uD83D\uDCBC', moved:'\uD83D\uDE9A',
     breakup:'\uD83D\uDC94', friendship:'\uD83E\uDD1D',
+    death:'\u2620\uFE0F', birthday:'\uD83C\uDF82', divorce:'\uD83D\uDC94',
+    politics:'\uD83C\uDFDB\uFE0F', bereavement:'\uD83D\uDE22',
   };
 
-  // Goals
+  // Goals — split into short-term and long-term
   const goals = data.goals || [];
   const activeGoals = goals.filter(g => g.status === 'active');
   const completedGoals = goals.filter(g => g.status === 'completed');
+  const shortTermGoals = activeGoals.filter(g => g.term === 'short');
+  const longTermGoals = activeGoals.filter(g => g.term !== 'short');
 
   // Children & pregnancy
   const children = data.children || [];
@@ -2800,15 +2812,26 @@ function renderAgentDetail(data) {
   const pregnantBadge = isPregnant ? ' \uD83E\uDD30' : '';
   const childrenBadge = children.length > 0 ? ` \uD83D\uDC76${children.length}` : '';
 
+  const isDead = data.alive === false;
+  const mayorBadge = data.is_mayor ? ' \uD83C\uDFDB\uFE0F Mayor' : '';
+  const lifeStageBadge = data.lifecycle_stage ? `<span style="color:#888;font-size:10px;margin-left:6px">${data.lifecycle_stage}</span>` : '';
+  const parentNames = (data.parent_names || []);
+  const deathInfo = isDead ? `<div style="margin:6px 0;padding:6px 8px;background:rgba(233,69,96,0.15);border:1px solid rgba(233,69,96,0.3);border-radius:4px;font-size:11px;color:#e94560">
+    \u2620\uFE0F Deceased (Day ${data.death_day}) — ${esc(data.death_cause || 'unknown')}</div>` : '';
+
   document.getElementById('agent-detail').innerHTML=`
     <div style="margin-bottom:6px">
       <span style="cursor:pointer;color:#888;font-size:11px" onclick="selectedAgentId=null;showDefaultDetail();">&larr; All Agents</span>
     </div>
     <h2>${gi} ${data.name||'?'}${pregnantBadge}${childrenBadge}</h2>
-    <p class="subtitle">${data.age||'?'} y/o ${data.occupation||''}</p>
+    <p class="subtitle">${data.age||'?'} y/o ${data.occupation||''}${mayorBadge}${lifeStageBadge}</p>
     <p class="subtitle" style="color:#888;font-size:10px">${data.traits||''}</p>
     <p class="subtitle" style="color:#e0e0e0">@ ${esc(locName)} &mdash; ${esc(data.action||'idle')}</p>
 
+    ${deathInfo}
+
+    ${parentNames.length>0?`<div style="margin:4px 0;font-size:10px;color:#888">\uD83D\uDC68\u200D\uD83D\uDC69\u200D\uD83D\uDC67 Parents: ${parentNames.map(n=>esc(n)).join(' & ')}</div>`:''}
+
     ${romanceRels.length>0?`<div style="margin:6px 0;padding:4px 8px;background:rgba(233,30,144,0.1);border:1px solid rgba(233,30,144,0.2);border-radius:4px;font-size:11px;color:#e91e90">
       ${romanceRels.map(r=>`\u2764 ${r.relationship_status} with ${r.name} (${(r.romantic_interest*100).toFixed(0)}%)`).join('<br>')}
     </div>`:''}
@@ -2817,6 +2840,7 @@ function renderAgentDetail(data) {
       \uD83D\uDC76 Children: ${children.map(c=>esc(c)).join(', ')}
     </div>`:''}
 
+    ${!isDead ? `
     <div class="bar-container">
       <div class="bar-label"><span>Mood: ${moodLabel}</span><span>${moodPct}%</span></div>
       <div class="bar-bg"><div class="bar-fill ${moodColor}" style="width:${moodPct}%"></div></div>
@@ -2833,10 +2857,11 @@ function renderAgentDetail(data) {
     <div style="margin-top:6px">
       <div style="font-size:10px;color:#888">Plan: ${esc((data.daily_plan||[]).slice(0,3).join('; ')||'None yet')}</div>
     </div>
+    ` : ''}
 
-    ${activeGoals.length>0||completedGoals.length>0?`
-    <div class="section-header">Goals</div>
-    ${activeGoals.map(g=>{
+    ${longTermGoals.length>0?`
+    <div class="section-header">Long-Term Goals</div>
+    ${longTermGoals.map(g=>{
       const pct=Math.round((g.progress||0)*100);
       return `<div style="margin:3px 0;font-size:11px">
         <div style="display:flex;justify-content:space-between;color:#e0e0f0">
@@ -2847,9 +2872,28 @@ function renderAgentDetail(data) {
         </div>
       </div>`;
     }).join('')}
-    ${completedGoals.slice(-3).map(g=>`<div style="margin:2px 0;font-size:10px;color:#555">\u2705 ${esc(g.description)}</div>`).join('')}
     `:''}
 
+    ${shortTermGoals.length>0?`
+    <div class="section-header">This Week's Goals</div>
+    ${shortTermGoals.map(g=>{
+      const pct=Math.round((g.progress||0)*100);
+      return `<div style="margin:3px 0;font-size:11px">
+        <div style="display:flex;justify-content:space-between;color:#e0e0f0">
+          <span>\u26A1 ${esc(g.description)}</span><span style="color:#888;font-size:9px">${pct}%</span>
+        </div>
+        <div style="height:3px;background:#1a1a3e;border-radius:2px;margin-top:2px">
+          <div style="height:100%;width:${pct}%;background:#f0c040;border-radius:2px"></div>
+        </div>
+      </div>`;
+    }).join('')}
+    `:''}
+
+    ${completedGoals.length>0?`
+    <div style="margin-top:4px">
+    ${completedGoals.slice(-3).map(g=>`<div style="margin:2px 0;font-size:10px;color:#555">\u2705 ${esc(g.description)}</div>`).join('')}
+    </div>`:''}
+
     ${lifeEvents.length>0?`
     <div class="section-header">Life History</div>
     <div style="max-height:160px;overflow-y:auto">
@@ -2888,6 +2932,13 @@ function renderAgentDetail(data) {
     <div class="section-header">Recent Memories</div>
     ${memories.map(m=>`<div class="memory-item"><span class="memory-time">${m.time||''}</span> ${esc(m.content||'')}</div>`).join('')||'<div class="memory-item" style="color:#555">No memories yet</div>'}
 
+    <div class="section-header">Ask About Memories</div>
+    <div style="display:flex;gap:4px;margin:4px 0">
+      <input type="text" id="memory-query-input" placeholder="e.g. Describe your feelings about..." style="flex:1;background:#0a1628;color:#e0e0e0;border:1px solid #1a3a6e;padding:5px 8px;border-radius:3px;font-size:11px" onkeydown="if(event.key==='Enter')askAgentMemory('${data.id}')">
+      <button onclick="askAgentMemory('${data.id}')" style="background:#4ecca3;color:#0a1628;border:none;padding:5px 10px;border-radius:3px;cursor:pointer;font-weight:700;font-size:11px">Ask</button>
+    </div>
+    <div id="memory-query-result" style="font-size:11px;color:#c0c0d0;margin:4px 0;max-height:200px;overflow-y:auto"></div>
+
     ${playerToken && playerAgentId && data.id !== playerAgentId ? `
     <div style="margin-top:10px">
       <button class="btn-primary" style="width:100%" onclick="openChat('${data.id}')">Talk to ${esc(data.name||'them')}</button>
@@ -2895,6 +2946,25 @@ function renderAgentDetail(data) {
   `;
 }
 
+async function askAgentMemory(agentId) {
+  const input = document.getElementById('memory-query-input');
+  const result = document.getElementById('memory-query-result');
+  const question = input.value.trim();
+  if (!question) return;
+  result.innerHTML = '<span style="color:#888">Thinking...</span>';
+  try {
+    const res = await fetch(`${API_BASE}/agents/${agentId}/ask`, {
+      method: 'POST',
+      headers: {'Content-Type': 'application/json'},
+      body: JSON.stringify({question}),
+    });
+    const data = await res.json();
+    result.innerHTML = `<div style="padding:6px 8px;background:rgba(78,204,163,0.06);border:1px solid rgba(78,204,163,0.15);border-radius:4px;margin-top:4px;line-height:1.5">${esc(data.answer || '(no response)')}</div><div style="color:#555;font-size:9px;margin-top:2px">${data.memories_used || 0} memories referenced</div>`;
+  } catch(e) {
+    result.innerHTML = `<span style="color:#e94560">Error: ${e.message}</span>`;
+  }
+}
+
 // ============================================================
 // CONVERSATIONS TAB
 // ============================================================
@@ -3026,6 +3096,7 @@ function processStateData(data) {
   }
 
   agents = data.agents || {};
+  window._mayorData = data.mayor || null;
   renderPlayerPanel();
 
   const tick = clock.total_ticks || 0;