Persist trader V4 P0 decision trace

src/test/java/com/quantai/trader/replay/TraderP0CycleRunnerTest.java

@@ -1,15 +1,20 @@
 package com.quantai.trader.replay;
 
 import com.quantai.trader.artifact.TraderArtifactLoader;
-import com.quantai.trader.domain.TraderActionFactory;
+import com.quantai.trader.domain.*;
 import com.quantai.trader.enums.TraderActionType;
 import com.quantai.trader.evidence.EvidenceAppender;
+import com.quantai.trader.evidence.TraderEvidenceRepository;
 import com.quantai.trader.model.DeterministicTraderModelService;
-import com.quantai.trader.outbox.InMemoryOutboxRepository;
+import com.quantai.trader.outbox.TraderOutboxEvent;
+import com.quantai.trader.outbox.TraderOutboxRepository;
+import com.quantai.trader.persistence.TraderDecisionTraceWriter;
 import com.quantai.trader.position.TraderPositionManager;
 import com.quantai.trader.risk.TraderRiskGate;
 import org.junit.jupiter.api.Test;
 
+import java.util.ArrayList;
+import java.util.List;
 import java.math.BigDecimal;
 
 import static com.quantai.trader.TestFixtures.T0;
@@ -19,8 +24,10 @@ import static org.assertj.core.api.Assertions.assertThat;
 class TraderP0CycleRunnerTest {
     @Test
     void runsReplayShadowCycleThroughModelPmRiskActionOutboxAndEvidence() {
-        EvidenceAppender evidenceAppender = new EvidenceAppender();
-        InMemoryOutboxRepository outboxRepository = new InMemoryOutboxRepository();
+        RecordingEvidenceRepository evidenceRepository = new RecordingEvidenceRepository();
+        EvidenceAppender evidenceAppender = new EvidenceAppender(evidenceRepository);
+        RecordingTraceWriter traceWriter = new RecordingTraceWriter();
+        RecordingOutboxRepository outboxRepository = new RecordingOutboxRepository();
         TraderP0CycleRunner runner = new TraderP0CycleRunner(
                 properties(),
                 new TraderArtifactLoader(properties()),
@@ -29,6 +36,7 @@ class TraderP0CycleRunnerTest {
                 new TraderRiskGate(),
                 new TraderActionFactory(),
                 evidenceAppender,
+                traceWriter,
                 outboxRepository);
 
         TraderCycleResult result = runner.runFlatCycle(new ReplayMarketEvent(
@@ -37,16 +45,19 @@ class TraderP0CycleRunnerTest {
 
         assertThat(result.action().actionType()).isEqualTo(TraderActionType.OPEN_LONG);
         assertThat(result.action().reduceOnly()).isFalse();
-        assertThat(outboxRepository.all()).hasSize(1);
-        assertThat(outboxRepository.all().getFirst().destination()).isEqualTo("SHADOW_RECORDER");
-        assertThat(evidenceAppender.all()).extracting("stage")
+        assertThat(traceWriter.actions()).containsExactly(result.action());
+        assertThat(outboxRepository.events()).hasSize(1);
+        assertThat(outboxRepository.events().getFirst().destination()).isEqualTo("SHADOW_RECORDER");
+        assertThat(evidenceRepository.items()).extracting("stage")
                 .containsExactly("MARKET_SNAPSHOT", "MODEL_OUTPUT", "PM_DECISION", "RISK_DECISION");
     }
 
     @Test
     void recordsWaitActionWhenReplaySnapshotHasNoLiquidity() {
-        EvidenceAppender evidenceAppender = new EvidenceAppender();
-        InMemoryOutboxRepository outboxRepository = new InMemoryOutboxRepository();
+        RecordingEvidenceRepository evidenceRepository = new RecordingEvidenceRepository();
+        EvidenceAppender evidenceAppender = new EvidenceAppender(evidenceRepository);
+        RecordingTraceWriter traceWriter = new RecordingTraceWriter();
+        RecordingOutboxRepository outboxRepository = new RecordingOutboxRepository();
         TraderP0CycleRunner runner = new TraderP0CycleRunner(
                 properties(),
                 new TraderArtifactLoader(properties()),
@@ -55,6 +66,7 @@ class TraderP0CycleRunnerTest {
                 new TraderRiskGate(),
                 new TraderActionFactory(),
                 evidenceAppender,
+                traceWriter,
                 outboxRepository);
 
         TraderCycleResult result = runner.runFlatCycle(new ReplayMarketEvent(
@@ -63,6 +75,49 @@ class TraderP0CycleRunnerTest {
 
         assertThat(result.action().actionType()).isEqualTo(TraderActionType.WAIT);
         assertThat(result.action().pricePlanId()).isNull();
-        assertThat(outboxRepository.all()).hasSize(1);
+        assertThat(traceWriter.actions()).containsExactly(result.action());
+        assertThat(outboxRepository.events()).hasSize(1);
+        assertThat(evidenceRepository.items()).hasSize(4);
+    }
+
+    private static final class RecordingEvidenceRepository implements TraderEvidenceRepository {
+        private final List<TraderEvidence> items = new ArrayList<>();
+
+        @Override
+        public void insert(TraderEvidence evidence) {
+            items.add(evidence);
+        }
+
+        List<TraderEvidence> items() {
+            return items;
+        }
+    }
+
+    private static final class RecordingOutboxRepository implements TraderOutboxRepository {
+        private final List<TraderOutboxEvent> events = new ArrayList<>();
+
+        @Override
+        public void insert(TraderOutboxEvent event) {
+            events.add(event);
+        }
+
+        List<TraderOutboxEvent> events() {
+            return events;
+        }
+    }
+
+    private static final class RecordingTraceWriter implements TraderDecisionTraceWriter {
+        private final List<TraderAction> actions = new ArrayList<>();
+
+        @Override
+        public void persistCycleTrace(TraderDecisionCycle cycle, TraderMarketSnapshot snapshot, TraderModelOutput modelOutput,
+                                      TraderPositionState positionState, TraderPositionManagerDecision pmDecision,
+                                      TraderRiskDecision riskDecision, TraderAction action) {
+            actions.add(action);
+        }
+
+        List<TraderAction> actions() {
+            return actions;
+        }
     }
 }