feat: wire simulation feedback loops (Phase 3 D1)

The simulation layers were modular but disconnected. Wire the three missing
feedback loops with targeted, additive changes (no new event bus):

Loop 1 -- world events -> stressors:
- Choice gains optional stressor / stressor_severity / resolves_stressor;
  EventOutcome carries stressor_added / stressor_resolved (apply_choice sets them).
- _process_life_events feeds the chosen outcome into the agent's SufferingState
  (add_stressor / resolve) -- add_stressor already tolerates new stressor names.
- A few catalog events declare stressors (big_loss/burnout cause; windfall/rest
  resolve) so the loop is exercised by real content.

Loop 2 -- stats -> goal generation (economy-gated):
- GoalContext.agent_stats; ExistenceLoop takes optional stats and renders a
  'Current condition' section (health/energy/happiness/reputation) in the prompt;
  the daemon passes self._stats.get(agent_id) into both goal-gen paths.

Loop 3 -- outcomes -> narrative:
- Goal abandonment now calls update_narrative (success already did); life events
  append a narrative entry. Reuses the existing 800-char update_narrative.

Tests: outcome stressor fields, daemon event->stressor add + resolve + narrative,
stats condition section present/absent. Docs: data-flow + feedback-loop note.
927 tests, ruff, format, mypy, mkdocs --strict all green. Fully additive.

Author: chiruu12

docs/guide/architecture.md

@@ -146,21 +146,28 @@ Each heartbeat (default 10s):
         - Pursue goal via Agent ReAct loop
         - Assess conditions (fire/resolve stressors)
         - On success: emit("goal_completed"), checkpoint, update narrative
-        - On failure: emit("goal_abandoned"), record stressor
+        - On failure: emit("goal_abandoned"), update narrative, record stressor
      f. If idle:
         - Check scheduled goals
-        - If custom GoalStrategy: call generate_goal(GoalContext)
-        - Else: run ExistenceLoop → LLM generates goal
+        - Generate a goal (custom GoalStrategy or ExistenceLoop). The prompt
+          includes the agent's stats (health/energy/happiness/reputation) so a
+          drained or unwell agent steers toward recovery (D1)
         - emit("goal_generated")
      g. Log suffering state
      h. emit("suffering_changed")
      i. emit("cycle_end")
   3. Auto-kill expired sub-agents
   4. Every 5 cycles: swarm learning
-  5. If economy: process payday + life events
+  5. If economy: process payday + life events. A life-event Choice may declare a
+     `stressor` it causes or `resolves_stressor` it relieves -- the daemon feeds
+     these into the agent's suffering, and records the event in its narrative (D1)
   6. Sleep heartbeat seconds
 ```
 
+**Feedback loops (D1).** The world, suffering, goals, and identity influence each
+other: life events add/resolve stressors and append to the narrative; agent stats
+feed goal generation; and both goal *and* event outcomes shape the agent's story.
+
 ## Configuration
 
 All config lives in `.hive/config.yaml` and env vars.

src/hive/agents/existence.py

@@ -18,6 +18,7 @@
 
 if TYPE_CHECKING:
     from hive.runtime.persona import Persona
+    from hive.world.stats import AgentStats
 
 logger = logging.getLogger(__name__)
 
@@ -40,6 +41,7 @@ def __init__(
         world_status: str = "",
         notepad_content: str = "",
         persona: Persona | None = None,
+        stats: AgentStats | None = None,
     ):
         self._agent_id = agent_id
         self._profile = profile
@@ -54,6 +56,7 @@ def __init__(
         self._world_status = world_status
         self._notepad_content = notepad_content
         self._persona = persona
+        self._stats = stats
 
     async def _emit(self, event_type: EventType, data: dict[str, Any]) -> None:
         event = HiveEvent(
@@ -217,6 +220,20 @@ def _build_prompt(
         if self._economy_enabled and self._world_status:
             sections.append(f"\n--- Your economic status ---\n{self._world_status}")
 
+        if self._stats is not None:
+            s = self._stats
+            condition = (
+                f"- Health: {s.health:.0%}\n"
+                f"- Energy: {s.energy:.0%}\n"
+                f"- Happiness: {s.happiness:.0%}\n"
+                f"- Reputation: {s.reputation:.0%}"
+            )
+            sections.append(
+                "\n--- Your current condition ---\n"
+                f"{condition}\n"
+                "Let low stats steer your goal (rest when drained, recover when unwell)."
+            )
+
         suffering_frag = suffering.prompt_fragment()
         if suffering_frag:
             sections.append(f"\n--- Your current state ---\n{suffering_frag}")

src/hive/agents/goal_strategy.py

@@ -9,6 +9,7 @@
     from hive.agents.profile import AgentProfile
     from hive.agents.suffering import SufferingState
     from hive.runtime.persona import Persona
+    from hive.world.stats import AgentStats
 
 
 @dataclass
@@ -31,6 +32,7 @@ class GoalContext:
     world_status: str = ""
     notepad_content: str = ""
     economy_enabled: bool = True
+    agent_stats: AgentStats | None = None
     extra: dict[str, Any] = field(default_factory=dict)
 
 

src/hive/daemon/loop.py

@@ -531,6 +531,13 @@ async def _run_agent_cycle_inner(self, agent: AgentState, suffering: SufferingSt
                 await self._hooks.emit(
                     "goal_abandoned", agent_id=agent.agent_id, goal_id=active_goal["goal_id"]
                 )
+                # D1: abandonment is part of the agent's story too (success path
+                # already records narrative; this closes the gap).
+                self._identity.update_narrative(
+                    agent.agent_id,
+                    active_goal["objective"],
+                    f"Abandoned: {outcome.summary}",
+                )
                 if persona is not None:
                     persona.update_from_event("goal_abandoned", outcome.summary)
                 self._specialization.record(
@@ -567,6 +574,9 @@ async def _run_agent_cycle_inner(self, agent: AgentState, suffering: SufferingSt
             if self._economy_enabled and self._ctx.world is not None:
                 world_status = self._ctx.world.get_status(agent.agent_id)
 
+            # D1: feed structured stats into goal generation (economy-gated).
+            agent_stats = self._stats.get(agent.agent_id) if self._stats else None
+
             notepad_content = self._notepad.get_tail(agent.agent_id)
 
             pending_a2a = await self._a2a_store.get_pending_requests(agent.agent_id, limit=3)
@@ -593,6 +603,7 @@ async def _run_agent_cycle_inner(self, agent: AgentState, suffering: SufferingSt
                     world_status=world_status,
                     notepad_content=notepad_content,
                     economy_enabled=self._economy_enabled,
+                    agent_stats=agent_stats,
                 )
                 result_goal = await self._goal_strategy.generate_goal(ctx)
                 if result_goal is not None:
@@ -621,6 +632,7 @@ async def _run_agent_cycle_inner(self, agent: AgentState, suffering: SufferingSt
                     world_status=world_status,
                     notepad_content=notepad_content,
                     persona=persona,
+                    stats=agent_stats,
                 )
                 goal = await existence.generate_goal(suffering, peers, nudges)
 
@@ -733,6 +745,30 @@ async def _process_life_events(self, agents: list[AgentState]) -> None:
                     self._cycle_count,
                 )
 
+                # D1: feed the chosen outcome back into the suffering system.
+                suffering = self._get_suffering(agent.agent_id)
+                if outcome.stressor_added:
+                    chosen = next((c for c in event.choices if c.id == outcome.choice_id), None)
+                    severity = chosen.stressor_severity if chosen else None
+                    suffering.add_stressor(
+                        outcome.stressor_added,
+                        description=f"Triggered by life event: {event.name}",
+                        observable_condition="Resolved by a positive life event or recovery",
+                        initial_severity=severity,
+                    )
+                if outcome.stressor_resolved:
+                    suffering.resolve(
+                        outcome.stressor_resolved,
+                        note=f"Relieved by life event: {event.name}",
+                    )
+
+                # D1: record the event in the agent's narrative (not just memory).
+                self._identity.update_narrative(
+                    agent.agent_id,
+                    f"Life event: {event.name}",
+                    outcome.choice_description,
+                )
+
                 session_id = f"sess-{agent.agent_id}"
                 await self._emit(
                     agent.agent_id,
@@ -743,6 +779,8 @@ async def _process_life_events(self, agents: list[AgentState]) -> None:
                         "choice": outcome.choice_description,
                         "stat_changes": outcome.stat_changes,
                         "follow_ups": outcome.follow_ups_triggered,
+                        "stressor_added": outcome.stressor_added,
+                        "stressor_resolved": outcome.stressor_resolved,
                     },
                 )
 

src/hive/world/event_catalog.py

@@ -333,6 +333,8 @@
                     StatEffect(stat="money", change=-1000),
                     StatEffect(stat="happiness", change=-25, change_type="percent"),
                 ],
+                stressor="financial_strain",
+                stressor_severity=0.4,
             ),
         ],
     ),
@@ -406,6 +408,7 @@
                     StatEffect(stat="money", change=300),
                     StatEffect(stat="happiness", change=5, change_type="percent"),
                 ],
+                resolves_stressor="financial_strain",
             ),
             Choice(
                 id="treat_yourself",
@@ -433,6 +436,7 @@
                     StatEffect(stat="happiness", change=10, change_type="percent"),
                     StatEffect(stat="money", change=-100),
                 ],
+                resolves_stressor="burnout",
             ),
             Choice(
                 id="push_through",
@@ -441,6 +445,8 @@
                     StatEffect(stat="energy", change=-0.2),
                     StatEffect(stat="health", change=-0.1),
                 ],
+                stressor="burnout",
+                stressor_severity=0.35,
             ),
         ],
     ),

src/hive/world/event_engine.py

@@ -127,6 +127,8 @@ def apply_choice(
             stat_changes=stat_changes,
             follow_ups_triggered=follow_ups,
             cycle=cycle,
+            stressor_added=choice.stressor,
+            stressor_resolved=choice.resolves_stressor,
         )
         self._history.append(outcome)
         self._persist_outcome(outcome)

src/hive/world/events.py

@@ -20,6 +20,13 @@ class Choice(BaseModel):
     description: str
     stat_effects: list[StatEffect] = []
     follow_up_events: list[ConditionalFollowUp] = []
+    # Feedback into the suffering system (D1). Optional; default None leaves
+    # existing events unchanged. ``stressor`` names a stressor this choice causes
+    # (any string -- SufferingState tolerates unregistered names); ``resolves_stressor``
+    # names one it relieves.
+    stressor: str | None = None
+    stressor_severity: float | None = None
+    resolves_stressor: str | None = None
 
 
 class LifeEvent(BaseModel):
@@ -41,3 +48,5 @@ class EventOutcome(BaseModel):
     stat_changes: dict[str, float] = {}
     follow_ups_triggered: list[str] = []
     cycle: int = 0
+    stressor_added: str | None = None
+    stressor_resolved: str | None = None