Implement Activation Phase 2 semantics (Option B)

Author: LegendaryForge

src/main/java/io/github/legendaryforge/legendary/core/api/activation/ActivationAttemptResult.java

@@ -8,4 +8,32 @@ public record ActivationAttemptResult(
         ActivationAttemptStatus status,
         ActivationDecision decision,
         Optional<UUID> sessionId,
-        Optional<EncounterInstance> instance) {}
+        Optional<EncounterInstance> instance) {
+
+    public ActivationAttemptResult {
+        if (status == null) throw new NullPointerException("status");
+        if (decision == null) throw new NullPointerException("decision");
+        if (sessionId == null) throw new NullPointerException("sessionId");
+        if (instance == null) throw new NullPointerException("instance");
+
+        // SUCCESS => allowed==true and sessionId present (session began)
+        if (status == ActivationAttemptStatus.SUCCESS) {
+            if (!decision.allowed()) {
+                throw new IllegalArgumentException("SUCCESS requires decision.allowed == true");
+            }
+            if (sessionId.isEmpty()) {
+                throw new IllegalArgumentException("SUCCESS requires sessionId");
+            }
+        }
+
+        // FAILED => sessionId absent and allowed==false (denied or fatal mapped to denial)
+        if (status == ActivationAttemptStatus.FAILED) {
+            if (sessionId.isPresent()) {
+                throw new IllegalArgumentException("FAILED must not have sessionId");
+            }
+            if (decision.allowed()) {
+                throw new IllegalArgumentException("FAILED requires decision.allowed == false");
+            }
+        }
+    }
+}

src/main/java/io/github/legendaryforge/legendary/core/api/activation/ActivationAttemptStatus.java

@@ -1,8 +1,6 @@
 package io.github.legendaryforge.legendary.core.api.activation;
 
 public enum ActivationAttemptStatus {
-    STARTED,
-    DENIED,
-    SESSION_REQUIRED,
+    SUCCESS,
     FAILED
 }

src/main/java/io/github/legendaryforge/legendary/core/internal/activation/DefaultActivationService.java

@@ -4,18 +4,89 @@
 import io.github.legendaryforge.legendary.core.api.activation.ActivationAttemptStatus;
 import io.github.legendaryforge.legendary.core.api.activation.ActivationDecision;
 import io.github.legendaryforge.legendary.core.api.activation.ActivationService;
+import io.github.legendaryforge.legendary.core.api.activation.session.ActivationSessionBeginResult;
+import io.github.legendaryforge.legendary.core.api.activation.session.ActivationSessionBeginStatus;
+import io.github.legendaryforge.legendary.core.api.activation.session.ActivationSessionService;
+import io.github.legendaryforge.legendary.core.api.encounter.EncounterKey;
+import io.github.legendaryforge.legendary.core.api.gate.ConditionGate;
+import io.github.legendaryforge.legendary.core.api.gate.GateDecision;
+import io.github.legendaryforge.legendary.core.api.gate.GateService;
 import io.github.legendaryforge.legendary.core.api.id.ResourceId;
+import java.util.Map;
+import java.util.Objects;
 import java.util.Optional;
 
 public final class DefaultActivationService implements ActivationService {
 
+    private final GateService gates;
+    private final ActivationSessionService sessions;
+
+    public DefaultActivationService(GateService gates, ActivationSessionService sessions) {
+        this.gates = Objects.requireNonNull(gates, "gates");
+        this.sessions = Objects.requireNonNull(sessions, "sessions");
+    }
+
     @Override
     public ActivationAttemptResult attemptActivation(ActivationAttemptRequest request) {
-        // Intentionally inert until Phase 1 · Step 3 wiring (authority + gate + session + encounter creation).
+        Objects.requireNonNull(request, "request");
+
+        EncounterKey encounterKey = EncounterKey.of(request.definition(), request.context());
+
+        // Phase 2: evaluate activation gate (if present)
+        ActivationDecision decision = request.activationGateKey()
+                .map(gateKey -> evaluateGate(gateKey, request, encounterKey))
+                .orElseGet(ActivationDecision::allow);
+
+        if (!decision.allowed()) {
+            return new ActivationAttemptResult(
+                    ActivationAttemptStatus.FAILED,
+                    decision,
+                    Optional.empty(),
+                    Optional.empty());
+        }
+
+        // Phase 2: begin activation session
+        ActivationSessionBeginResult begin = sessions.begin(
+                new ActivationSessionService.ActivationSessionBeginRequest(
+                        request.activatorId(),
+                        encounterKey,
+                        request.definition(),
+                        request.context(),
+                        request.activationGateKey(),
+                        decision.attributes()
+                )
+        );
+
+        if (begin.status() == ActivationSessionBeginStatus.CREATED || begin.status() == ActivationSessionBeginStatus.EXISTING) {
+            return new ActivationAttemptResult(
+                    ActivationAttemptStatus.SUCCESS,
+                    decision,
+                    Optional.of(begin.sessionId()),
+                    Optional.empty());
+        }
+
+        // DENIED => FAILED
+        ActivationDecision denied = ActivationDecision.deny(begin.reasonCode(), decision.attributes());
         return new ActivationAttemptResult(
                 ActivationAttemptStatus.FAILED,
-                ActivationDecision.deny(ResourceId.of("legendarycore", "not_wired")),
+                denied,
                 Optional.empty(),
                 Optional.empty());
     }
+
+    private ActivationDecision evaluateGate(ResourceId gateKey, ActivationAttemptRequest request, EncounterKey encounterKey) {
+        ConditionGate.GateRequest gateRequest = new ConditionGate.GateRequest(
+                gateKey,
+                request.activatorId(),
+                Optional.of(encounterKey),
+                Optional.empty(),
+                Optional.empty(),
+                Map.of()
+        );
+
+        GateDecision gateDecision = gates.evaluate(gateRequest);
+        return gateDecision.allowed()
+                ? ActivationDecision.allow()
+                : ActivationDecision.deny(gateDecision.reasonCode(), gateDecision.attributes());
+    }
 }

src/main/java/io/github/legendaryforge/legendary/core/internal/runtime/DefaultCoreRuntime.java

@@ -121,7 +121,7 @@ public DefaultCoreRuntime(Optional<PlayerDirectory> players, Optional<PartyDirec
         ActivationSessionService sessions = new DefaultActivationSessionService();
         this.services.register(ActivationSessionService.class, sessions);
 
-        ActivationService activations = new DefaultActivationService();
+        ActivationService activations = new DefaultActivationService(gates, sessions);
         this.services.register(ActivationService.class, activations);
 
         bus.subscribe(