feat(inference): emit MVP-shaped attributed event payloads

Extend the legacy inference JSONL output so possession-engine events now also produce attributed MVP event rows shaped for the deterministic event-rule engine. This preserves the existing raw pass/catch/steal rows while adding rule-validated pass, catch, steal, and derived turnover payloads with stat deltas where the current evidence supports them.

Also thread the prior-handler id through steal events so turnovers can be attributed, add focused inference tests for the new adapter behavior, and advance the plan frontier to the next evidence gap: shot and rebound attribution once better ball-result signals are available.

Author: dibsonmuad

TASK_STATUS.md

@@ -7,7 +7,7 @@ The old chapter-style status model is retired. This file now tracks the current
 ## Current Frontier
 
 The current highest-priority frontier is:
-- `L3.71` emit first attributed MVP event payloads in the shape required by the deterministic event-rule engine
+- `L3.72` extend attributed MVP event emission to shot and rebound evidence once ball-result signals are available
 - `L3.66` add bounded multi-hypothesis identity infrastructure for ambiguous short-gap track continuity
 - `L3.64` add a minimal ball artifact to Layer 1 review outputs and use it to refine live-play gating
 - `L3.63` add explicit playback transport controls and conservative jersey-OCR display gating in the labeller
@@ -120,6 +120,7 @@ The current highest-priority frontier is:
 - [x] Check in an explicit Layer 1 identity-policy contract and machine-readable rules file
 - [x] Check in machine-readable MVP event-evidence rules and a loader for deterministic stat attribution
 - [x] Make the first deterministic event-attribution path consume the checked-in MVP event rules
+- [x] Emit first attributed MVP event payloads in the shape required by the deterministic event-rule engine
 - [ ] Add a minimal ball artifact to Layer 1 review outputs and use it to refine live-play gating
 - [ ] Add bounded multi-hypothesis identity infrastructure for ambiguous short-gap track continuity
 - [ ] Add explicit playback transport controls and conservative jersey-OCR display gating in the labeller
@@ -155,7 +156,7 @@ The current highest-priority frontier is:
 - [ ] Implement dynamic perception audit script (scripts/run_perception_audit.sh)
 
 ### Active or Next
-- [ ] Emit first attributed MVP event payloads in the shape required by the deterministic event-rule engine
+- [ ] Extend attributed MVP event emission to shot and rebound evidence once ball-result signals are available
 - [ ] Add bounded multi-hypothesis identity infrastructure for ambiguous short-gap track continuity
 - [ ] Add a minimal ball artifact to Layer 1 review outputs and use it to refine live-play gating
 - [ ] Add explicit playback transport controls and conservative jersey-OCR display gating in the labeller

docs/plan/PLAN_TREE.yaml

@@ -517,6 +517,11 @@ levels:
       parent: L2.13
       title: Emit first attributed MVP event payloads in the shape required by the deterministic event-rule engine
       owner: A0
+      status: completed
+    - id: L3.72
+      parent: L2.13
+      title: Extend attributed MVP event emission to shot and rebound evidence once ball-result signals are available
+      owner: A0
       status: in_progress
     - id: L3.42
       parent: L2.32
@@ -601,7 +606,7 @@ levels:
 
 priorities:
   current_frontier:
-    - L3.71
+    - L3.72
     - L3.66
     - L3.64
     - L3.63

pipelines/behavior_engine.py

@@ -112,7 +112,7 @@ def update(self, player_tracks, ball_pos_3d, t_ms):
                         })
                     else:
                         events.append({
-                            "kind": "steal", "player_id": best_tid, "t_ms": t_ms,
+                            "kind": "steal", "player_id": best_tid, "from": self.current_handler, "t_ms": t_ms,
                             "x": float(ball_pos_3d[0]), "y": float(ball_pos_3d[1])
                         })
                 self.last_handler = self.current_handler

pipelines/inference.py

@@ -9,6 +9,7 @@
 
 from pipelines.behavior_engine import BehaviorStateMachine, PossessionEngine
 from pipelines.geometry import lift_keypoints_to_3d, project_pixel_to_court
+from pipelines.mvp_event_engine import MvpEventRuleEngine
 
 
 def get_label_map(spec_path="specs/basketball_ncaa.yaml"):
@@ -284,6 +285,108 @@ def write(self, payload):
         self._fh.write(json.dumps(payload) + "\n")
 
 
+class MvpEventAdapter:
+    """Translate legacy runtime events into MVP-attribution payloads.
+
+    The legacy inference path already emits simple `pass` / `catch` / `steal`
+    events. This adapter preserves those rows and adds a parallel
+    `attributed_event` contract shaped for the deterministic MVP event-rule
+    engine.
+    """
+
+    def __init__(self, rule_engine=None):
+        self.rule_engine = rule_engine or MvpEventRuleEngine()
+
+    def adapt(self, raw_event, player_map):
+        kind = raw_event.get("kind")
+        if kind == "catch":
+            return [self._build_and_count(
+                event_type="catch",
+                actor_id=raw_event.get("player_id"),
+                team_id=self._team_for(player_map, raw_event.get("player_id")),
+                t_ms=raw_event.get("t_ms"),
+                evidence={},
+            )]
+        if kind == "pass":
+            return [self._build_and_count(
+                event_type="pass",
+                actor_id=raw_event.get("from"),
+                secondary_actor_id=raw_event.get("to"),
+                team_id=raw_event.get("team_id") or self._team_for(player_map, raw_event.get("from")),
+                t_ms=raw_event.get("t_ms"),
+                next_event_type="catch",
+                evidence={},
+            )]
+        if kind == "steal":
+            outputs = []
+            offender_id = raw_event.get("from")
+            if offender_id is not None:
+                outputs.append(self._build_and_count(
+                    event_type="turnover",
+                    actor_id=offender_id,
+                    secondary_actor_id=raw_event.get("player_id"),
+                    team_id=self._team_for(player_map, offender_id),
+                    t_ms=raw_event.get("t_ms"),
+                    next_event_type="steal",
+                    evidence={"loss_of_team_control": True},
+                ))
+            outputs.append(self._build_and_count(
+                event_type="steal",
+                actor_id=raw_event.get("player_id"),
+                secondary_actor_id=offender_id,
+                team_id=raw_event.get("team_id") or self._team_for(player_map, raw_event.get("player_id")),
+                t_ms=raw_event.get("t_ms"),
+                evidence={"possession_gain": True},
+            ))
+            return outputs
+        return []
+
+    def _build_and_count(
+        self,
+        *,
+        event_type,
+        actor_id,
+        team_id,
+        t_ms,
+        evidence,
+        secondary_actor_id=None,
+        preceding_event_type=None,
+        next_event_type=None,
+        terminal_event_type=None,
+        shot_value=None,
+    ):
+        payload = {
+            "kind": "attributed_event",
+            "event_type": event_type,
+            "actor_id": int(actor_id) if actor_id is not None else None,
+            "secondary_actor_id": int(secondary_actor_id) if secondary_actor_id is not None else None,
+            "team_id": int(team_id) if team_id is not None else None,
+            "t_ms": int(t_ms) if t_ms is not None else None,
+            "live_play": True,
+            "preceding_event_type": preceding_event_type,
+            "next_event_type": next_event_type,
+            "terminal_event_type": terminal_event_type,
+            "shot_value": shot_value,
+            "evidence": evidence or {},
+        }
+        payload["rule_validation"] = self.rule_engine.validate_event(payload)
+        payload["stat_deltas"] = (
+            {}
+            if payload["rule_validation"]
+            else self.rule_engine.stat_deltas_for_event(payload)
+        )
+        return payload
+
+    @staticmethod
+    def _team_for(player_map, player_id):
+        if player_id is None:
+            return None
+        player_state = player_map.get(player_id)
+        if not player_state:
+            return None
+        return player_state.get("team")
+
+
 class FrameResultAdapter:
     """Translate raw Ultralytics frame results into pipeline-friendly pieces.
 
@@ -366,6 +469,7 @@ def __init__(self, config, models, calibration):
         self.frame_idx = 0
         self.tracks = {}
         self.possession_engine = PossessionEngine()
+        self.mvp_event_adapter = MvpEventAdapter()
         self.last_ball_2d = np.array([0.0, 0.0])
 
     def run(self):
@@ -433,6 +537,8 @@ def _write_possession_events(self, player_map, ball_3d, t_ms, writer):
         possession_events = self.possession_engine.update(player_map, ball_3d, t_ms)
         for event in possession_events:
             writer.write(event)
+            for attributed_event in self.mvp_event_adapter.adapt(event, player_map):
+                writer.write(attributed_event)
 
     def _write_player_events(self, player_map, h_matrix, t_ms, writer):
         """Emit one player-state row per currently visible tracked player."""

tests/test_inference_pipeline.py

@@ -9,6 +9,7 @@
     BALL_CLASS_ID,
     CalibrationResolver,
     FrameResultAdapter,
+    MvpEventAdapter,
 )
 
 
@@ -75,5 +76,40 @@ def test_extract_ball_state_updates_last_ball_and_writes_event(self):
         self.assertEqual(writer.rows[0]["t_ms"], 250)
 
 
+class MvpEventAdapterTest(unittest.TestCase):
+    def setUp(self):
+        self.adapter = MvpEventAdapter()
+        self.player_map = {
+            7: {"team": 1},
+            9: {"team": 1},
+            14: {"team": 2},
+        }
+
+    def test_adapt_pass_emits_attributed_event(self):
+        rows = self.adapter.adapt(
+            {"kind": "pass", "from": 7, "to": 9, "team_id": 1, "t_ms": 500},
+            self.player_map,
+        )
+        self.assertEqual(len(rows), 1)
+        self.assertEqual(rows[0]["kind"], "attributed_event")
+        self.assertEqual(rows[0]["event_type"], "pass")
+        self.assertEqual(rows[0]["actor_id"], 7)
+        self.assertEqual(rows[0]["secondary_actor_id"], 9)
+        self.assertEqual(rows[0]["stat_deltas"], {})
+        self.assertEqual(rows[0]["rule_validation"], [])
+
+    def test_adapt_steal_emits_turnover_and_steal(self):
+        rows = self.adapter.adapt(
+            {"kind": "steal", "player_id": 14, "from": 7, "team_id": 2, "t_ms": 800},
+            self.player_map,
+        )
+        self.assertEqual([row["event_type"] for row in rows], ["turnover", "steal"])
+        turnover, steal = rows
+        self.assertEqual(turnover["stat_deltas"]["TOs"], 1)
+        self.assertEqual(steal["stat_deltas"]["Steals"], 1)
+        self.assertEqual(turnover["rule_validation"], [])
+        self.assertEqual(steal["rule_validation"], [])
+
+
 if __name__ == "__main__":
     unittest.main()