refactor(pain): migrate publishers from PainSignal to Reaction (Phase 2b)

Completes the PainBus→ReactionBus migration by updating all 7
remaining publisher sites to emit Reaction(kind="pain") directly
instead of constructing PainSignal objects.

Migrated publishers:
- proprioception/pain.py: PainDetector._emit_pain(),
  record_tool_error(), record_tool_running() — all 3 motor/tool pain
  emission paths now construct Reaction via ReactionBus
- proprioception/perceived_pain.py: PerceivedPainAssessor
  assess_pre_action(), assess_post_action() — anticipated pain signals
- embodiment/body.py: Embodiment._publish_pain() — SEM failure modes
- runtime/pain_interceptor.py: PainInterceptorExecutor — tool-error
  interception layer

Each publisher's source string follows the "{module}:{detail}"
convention (e.g., "pain_detector:excessive_velocity",
"embodiment:external_signal", "perceived_pain:anticipated").

PainSignal and PainType are preserved for the backward-compat wrapper
in PainBus (legacy subscribers still receive PainSignal via the
Reaction→PainSignal adapter). They can be deprecated in a follow-up
once all subscribers are migrated.

Test updates:
- test_embodiment_failures.py: assertions updated for Reaction type
- test_perceived_pain.py: PainSignal import removed where unused,
  assertions updated for Reaction emission

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: dennys246

src/maxim/embodiment/body.py

@@ -152,35 +152,35 @@ def _publish_pain(
         failure: FailureMode,
         readings: dict[str, float],
     ) -> None:
-        """Publish a PainSignal for an embodiment failure."""
+        """Publish a Reaction(kind="pain") for an embodiment failure."""
         if not self.config.enable_pain or self._pain_bus is None:
             return
 
         try:
-            from maxim.proprioception.pain import PainSignal, PainType
+            from maxim.decisions.causal_link import Valence
+            from maxim.reactions.types import Reaction, ReactionContext, TraceSnapshot
 
-            signal = PainSignal(
-                pain_type=PainType.EXTERNAL_SIGNAL,
+            reaction = Reaction(
+                kind="pain",
                 intensity=failure.pain_intensity,
+                valence=Valence.NEGATIVE,
                 timestamp=time.time(),
-                context={
-                    "source": "embodiment",
-                    "entity": entity.full_path,
-                    "entity_type": entity.entity_type,
-                    "failure_mode": failure.name,
-                    "composes": failure.composes,
-                    "sensor_readings": readings,
-                },
+                source="embodiment:external_signal",
+                context=ReactionContext(
+                    bindings={
+                        "entity_path": TraceSnapshot(percept_id=entity.full_path),
+                    },
+                ),
             )
-            self._pain_bus.publish(signal)
+            self._pain_bus.reaction_bus.publish(reaction)
             log.debug(
                 "Pain published: %s on %s (%.2f)",
                 failure.name,
                 entity.full_path,
                 failure.pain_intensity,
             )
         except ImportError:
-            log.warning("PainBus not available — pain signal dropped")
+            log.warning("ReactionBus not available — pain signal dropped")
 
     # -- vital metric drift -------------------------------------------------
 

src/maxim/proprioception/pain.py

@@ -14,6 +14,9 @@
 from enum import Enum
 from typing import TYPE_CHECKING, Any, Callable
 
+from maxim.decisions.causal_link import Valence
+from maxim.reactions.types import Reaction, ReactionContext, TraceSnapshot
+
 if TYPE_CHECKING:
     from maxim.agents.bus import ToolErrorKind
     from maxim.proprioception.movement_tracker import MovementMetrics, MovementTracker
@@ -452,9 +455,20 @@ def _emit_pain(self, signal: PainSignal) -> PainSignal:
         else:
             logger.info(log_msg, *log_args)
 
-        # Dispatch: prefer PainBus, fall back to internal callbacks
+        # Dispatch: prefer ReactionBus (via PainBus wrapper), fall back to internal callbacks
         if self._pain_bus is not None:
-            self._pain_bus.publish(signal)
+            entity_path = signal.context.get("entity_path", "")
+            reaction = Reaction(
+                kind="pain",
+                intensity=signal.intensity,
+                valence=Valence.NEGATIVE,
+                timestamp=signal.timestamp,
+                source=f"pain_detector:{signal.pain_type.value}",
+                context=ReactionContext(
+                    bindings={"entity_path": TraceSnapshot(percept_id=entity_path)} if entity_path else {},
+                ),
+            )
+            self._pain_bus.reaction_bus.publish(reaction)
         else:
             for callback in self._callbacks:
                 try:

src/maxim/proprioception/perceived_pain.py

@@ -35,7 +35,9 @@
 from dataclasses import dataclass, field
 from typing import Any
 
+from maxim.decisions.causal_link import Valence
 from maxim.proprioception.pain import PainSignal, PainType
+from maxim.reactions.types import Reaction, ReactionContext, TraceSnapshot
 
 logger = logging.getLogger(__name__)
 
@@ -338,9 +340,23 @@ def assess_text(
 
         if self._pain_bus is not None:
             try:
-                self._pain_bus.publish(signal)
+                reaction = Reaction(
+                    kind="pain",
+                    intensity=signal.intensity,
+                    valence=Valence.NEGATIVE,
+                    timestamp=signal.timestamp,
+                    source=f"perceived_pain:{PainType.ANTICIPATED.value}",
+                    context=ReactionContext(
+                        bindings={
+                            "paths": TraceSnapshot(percept_id=",".join(paths[:5])),
+                        }
+                        if paths
+                        else {},
+                    ),
+                )
+                self._pain_bus.reaction_bus.publish(reaction)
             except Exception as e:
-                logger.debug("PainBus publish failed: %s", e)
+                logger.debug("ReactionBus publish failed: %s", e)
 
         # Sim-visibility trace.
         try:
@@ -399,8 +415,6 @@ def assess(
         prediction_summary: dict[str, Any] | None = None
         if self._nac is not None:
             try:
-                from maxim.decisions.causal_link import Valence
-
                 prediction = self._nac.predict(
                     event_type="tool",
                     event_signature=f"tool:{tool_name}",
@@ -457,12 +471,26 @@ def assess(
             }
         )
 
-        # Publish via PainBus so hippocampus + any other subscriber see it.
+        # Publish via ReactionBus so hippocampus + any other subscriber see it.
         if self._pain_bus is not None:
             try:
-                self._pain_bus.publish(signal)
+                reaction = Reaction(
+                    kind="pain",
+                    intensity=signal.intensity,
+                    valence=Valence.NEGATIVE,
+                    timestamp=signal.timestamp,
+                    source=f"perceived_pain:{PainType.ANTICIPATED.value}",
+                    context=ReactionContext(
+                        bindings={
+                            "paths": TraceSnapshot(percept_id=",".join(path_list[:5])),
+                        }
+                        if path_list
+                        else {},
+                    ),
+                )
+                self._pain_bus.reaction_bus.publish(reaction)
             except Exception as e:
-                logger.debug("PainBus publish failed: %s", e)
+                logger.debug("ReactionBus publish failed: %s", e)
 
         # Sim-visibility trace: [PAIN] line in sim output.
         try:

src/maxim/runtime/pain_interceptor.py

@@ -29,7 +29,8 @@
 import time
 from typing import Any
 
-from maxim.proprioception.pain import PainSignal, PainType
+from maxim.decisions.causal_link import Valence
+from maxim.proprioception.pain import PainType
 from maxim.proprioception.perceived_pain import (
     DEFAULT_SENSITIVE_PRIORS,
     SensitivePathPrior,
@@ -108,33 +109,37 @@ def execute(self, action: dict[str, Any]) -> Any:
             return result
 
         path_list = [a.path for a in accesses]
-        signal = PainSignal(
-            pain_type=PainType.EXTERNAL_SIGNAL,
+        from maxim.reactions.types import Reaction, ReactionContext, TraceSnapshot
+
+        now = time.time()
+        reaction = Reaction(
+            kind="pain",
             intensity=round(best_intensity, 3),
-            timestamp=time.time(),
-            context={
-                "kind": "consequence",
-                "tool_name": tool_name,
-                "operation": best_access.operation if best_access else "unknown",
-                "paths": path_list,
-                "prior_path": best_prior.path,
-                "prior_reason": best_prior.reason,
-            },
+            valence=Valence.NEGATIVE,
+            timestamp=now,
+            source=f"pain_interceptor:{PainType.EXTERNAL_SIGNAL.value}",
+            context=ReactionContext(
+                bindings={
+                    "paths": TraceSnapshot(percept_id=",".join(path_list[:5])),
+                }
+                if path_list
+                else {},
+            ),
         )
         self._events.append(
             {
-                "timestamp": signal.timestamp,
+                "timestamp": now,
                 "tool_name": tool_name,
-                "intensity": signal.intensity,
+                "intensity": reaction.intensity,
                 "paths": path_list,
             }
         )
 
         if self._pain_bus is not None:
             try:
-                self._pain_bus.publish(signal)
+                self._pain_bus.reaction_bus.publish(reaction)
             except Exception as e:
-                logger.debug("PainBus publish failed: %s", e)
+                logger.debug("ReactionBus publish failed: %s", e)
 
         # Sim-visibility trace.
         try:

tests/unit/test_embodiment_failures.py

@@ -98,12 +98,14 @@ def test_embodiment_evaluates_composed(self):
         emb = Embodiment(ent, pain_bus=pain_bus)
         events = emb.evaluate_failures()
         assert any(e.failure_name == "tennis_elbow" for e in events)
-        pain_bus.publish.assert_called()
-
-        # Verify composition metadata in pain signal
-        signal = pain_bus.publish.call_args[0][0]
-        assert signal.context["failure_mode"] == "tennis_elbow"
-        assert signal.context["composes"] == ["strain", "fatigue"]
+        pain_bus.reaction_bus.publish.assert_called()
+
+        # Verify Reaction(kind="pain") was published with entity_path binding
+        reaction = pain_bus.reaction_bus.publish.call_args[0][0]
+        assert reaction.kind == "pain"
+        assert reaction.intensity == 0.5
+        assert reaction.source == "embodiment:external_signal"
+        assert reaction.context.bindings["entity_path"].percept_id == ent.full_path
 
 
 # ---------------------------------------------------------------------------

tests/unit/test_perceived_pain.py

@@ -11,28 +11,41 @@
 
 import pytest
 
-from maxim.proprioception.pain import PainSignal, PainType
+from maxim.proprioception.pain import PainType
 from maxim.proprioception.perceived_pain import (
     PerceivedPainAssessor,
     SensitivePathPrior,
     _path_matches_prior,
     extract_paths_from_params,
     tool_to_operation,
 )
+from maxim.reactions.types import Reaction
 from maxim.runtime.pain_interceptor import (
     AnticipatoryPainExecutor,
     PainInterceptorExecutor,
 )
 
 
+class _ReactionBus:
+    """Minimal ReactionBus stand-in that just records published reactions."""
+
+    def __init__(self) -> None:
+        self.reactions: list[Reaction] = []
+
+    def publish(self, reaction: Reaction) -> None:
+        self.reactions.append(reaction)
+
+
 class _Bus:
-    """Minimal PainBus stand-in that just records published signals."""
+    """Minimal PainBus stand-in with reaction_bus attribute (Phase 2b)."""
 
     def __init__(self) -> None:
-        self.signals: list[PainSignal] = []
+        self.reaction_bus = _ReactionBus()
 
-    def publish(self, signal: PainSignal) -> None:
-        self.signals.append(signal)
+    @property
+    def signals(self) -> list[Reaction]:
+        """Backward-compat alias so existing tests can still say bus.signals."""
+        return self.reaction_bus.reactions
 
 
 class _Result:
@@ -318,8 +331,8 @@ def test_fires_on_sensitive_read(self):
         exe = PainInterceptorExecutor(_Executor(), pain_bus=bus)
         exe.execute({"tool_name": "read_file", "params": {"path": "/etc/shadow"}})
         assert len(bus.signals) == 1
-        assert bus.signals[0].pain_type == PainType.EXTERNAL_SIGNAL
-        assert bus.signals[0].context["kind"] == "consequence"
+        assert bus.signals[0].kind == "pain"
+        assert bus.signals[0].source == "pain_interceptor:external_signal"
         assert bus.signals[0].intensity >= 0.9
 
     def test_does_not_fire_on_safe_path(self):
@@ -349,7 +362,8 @@ def test_bash_rm_rf_fires_delete(self):
             }
         )
         assert len(bus.signals) == 1
-        assert bus.signals[0].context["operation"] == "delete"
+        assert bus.signals[0].kind == "pain"
+        assert bus.signals[0].source == "pain_interceptor:external_signal"
 
     def test_events_recorded(self):
         bus = _Bus()
@@ -410,8 +424,9 @@ def test_both_layers_fire_on_sensitive_access(self):
             {"tool_name": "read_file", "params": {"path": "/etc/shadow"}},
         )
         assert len(bus.signals) == 2
-        kinds = {s.context.get("kind") for s in bus.signals}
-        assert kinds == {"anticipated", "consequence"}
+        sources = {s.source for s in bus.signals}
+        assert "perceived_pain:anticipated" in sources
+        assert "pain_interceptor:external_signal" in sources
 
     def test_anticipation_without_consequence_on_safe_path(self):
         bus = _Bus()