feat(domain): migrate ScopeAggregate to jMolecules AggregateRoot

Changes:
- Implement jMolecules AggregateRoot<ScopeAggregate, ScopeId>
- Add getId(): ScopeId implementation
- Internalize event sourcing support (raiseEvent, applyEvent, uncommittedEvents)
- Maintain dual identity system (_id + deprecated aggregateId) for compatibility
- Remove platform-dependent methods (handleCreate, decideUpdateTitle, handleUpdateTitle)
- Update factory methods to use new constructor signature
- Fix event creation to use deprecated aggregateId field

Design decisions:
- jMolecules AggregateRoot is a marker interface, event sourcing logic moved to internal implementation
- Deprecated aggregateId field maintained for backward compatibility during migration
- Removed decide/evolve pattern methods that depended on platform utilities
- Simplified API focused on core aggregate operations

Build status: ✅ SUCCESS (with expected deprecation warnings)

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: kamiazya

contexts/scope-management/domain/src/main/kotlin/io/github/kamiazya/scopes/scopemanagement/domain/aggregate/ScopeAggregate.kt

@@ -4,13 +4,10 @@ import arrow.core.Either
 import arrow.core.raise.either
 import arrow.core.raise.ensure
 import arrow.core.raise.ensureNotNull
-import io.github.kamiazya.scopes.platform.domain.aggregate.AggregateResult
-import io.github.kamiazya.scopes.platform.domain.aggregate.AggregateRoot
-import io.github.kamiazya.scopes.platform.domain.event.EventEnvelope
-import io.github.kamiazya.scopes.platform.domain.event.evolveWithPending
 import io.github.kamiazya.scopes.platform.domain.value.AggregateId
 import io.github.kamiazya.scopes.platform.domain.value.AggregateVersion
 import io.github.kamiazya.scopes.platform.domain.value.EventId
+import org.jmolecules.ddd.types.AggregateRoot
 import io.github.kamiazya.scopes.scopemanagement.domain.entity.Scope
 import io.github.kamiazya.scopes.scopemanagement.domain.error.ScopeError
 import io.github.kamiazya.scopes.scopemanagement.domain.error.ScopesError
@@ -33,7 +30,7 @@ import kotlinx.datetime.Clock
 import kotlinx.datetime.Instant
 
 /**
- * Scope aggregate root implementing event sourcing pattern.
+ * Scope aggregate root implementing event sourcing pattern with jMolecules DDD types.
  *
  * This aggregate encapsulates all business logic related to Scopes,
  * ensuring that all state changes go through proper domain events.
@@ -44,16 +41,66 @@ import kotlinx.datetime.Instant
  * - Business rules are validated before generating events
  * - The aggregate can be reconstructed from its event history
  * - Commands return new instances (immutability)
+ * - Implements jMolecules AggregateRoot<ScopeAggregate, ScopeId> for explicit DDD modeling
  */
 data class ScopeAggregate(
-    override val id: AggregateId,
-    override val version: AggregateVersion,
+    private val _id: ScopeId,
+    @Deprecated("Use ScopeId directly instead of AggregateId", ReplaceWith("_id"))
+    val aggregateId: AggregateId,
+    val version: AggregateVersion,
     val createdAt: Instant,
     val updatedAt: Instant,
     val scope: Scope?,
     val isDeleted: Boolean = false,
     val isArchived: Boolean = false,
-) : AggregateRoot<ScopeAggregate, ScopeEvent>() {
+) : AggregateRoot<ScopeAggregate, ScopeId> {
+
+    override fun getId(): ScopeId = _id
+
+    // Event sourcing support - uncommitted events tracking
+    private val uncommittedEventsList = mutableListOf<ScopeEvent>()
+    val uncommittedEvents: List<ScopeEvent> get() = uncommittedEventsList.toList()
+
+    /**
+     * Raise a new domain event and apply it to update state.
+     */
+    protected fun raiseEvent(event: ScopeEvent): ScopeAggregate {
+        uncommittedEventsList.add(event)
+        return applyEvent(event)
+    }
+
+    /**
+     * Mark all uncommitted events as committed.
+     * Called after successful persistence.
+     */
+    fun markEventsAsCommitted() {
+        uncommittedEventsList.clear()
+    }
+
+    /**
+     * Get and clear uncommitted events atomically.
+     */
+    fun getAndClearUncommittedEvents(): List<ScopeEvent> {
+        val events = uncommittedEventsList.toList()
+        uncommittedEventsList.clear()
+        return events
+    }
+
+    /**
+     * Check if there are any uncommitted changes.
+     */
+    fun hasUncommittedChanges(): Boolean = uncommittedEventsList.isNotEmpty()
+
+    /**
+     * Replay events to rebuild aggregate state.
+     */
+    fun replayEvents(events: List<ScopeEvent>): ScopeAggregate {
+        var aggregate = this
+        for (event in events) {
+            aggregate = aggregate.applyEvent(event)
+        }
+        return aggregate
+    }
 
     companion object {
         /**
@@ -85,7 +132,8 @@ data class ScopeAggregate(
             )
 
             val initialAggregate = ScopeAggregate(
-                id = aggregateId,
+                _id = scopeId,
+                aggregateId = aggregateId,
                 version = AggregateVersion.initial(),
                 createdAt = now,
                 updatedAt = now,
@@ -97,63 +145,14 @@ data class ScopeAggregate(
             initialAggregate.raiseEvent(event)
         }
 
-        /**
-         * Creates a scope using decide/evolve pattern.
-         * Returns an AggregateResult with the new aggregate and pending events.
-         */
-        fun handleCreate(
-            title: String,
-            description: String? = null,
-            parentId: ScopeId? = null,
-            scopeId: ScopeId? = null,
-            now: Instant = Clock.System.now(),
-        ): Either<ScopesError, AggregateResult<ScopeAggregate, ScopeEvent>> = either {
-            val validatedTitle = ScopeTitle.create(title).bind()
-            val validatedDescription = ScopeDescription.create(description).bind()
-            val scopeId = scopeId ?: ScopeId.generate()
-            val aggregateId = scopeId.toAggregateId().bind()
-
-            val initialAggregate = ScopeAggregate(
-                id = aggregateId,
-                version = AggregateVersion.initial(),
-                createdAt = now,
-                updatedAt = now,
-                scope = null,
-                isDeleted = false,
-                isArchived = false,
-            )
-
-            // Decide phase - create events with dummy version
-            val event = ScopeCreated(
-                aggregateId = aggregateId,
-                eventId = EventId.generate(),
-                occurredAt = now,
-
-                aggregateVersion = AggregateVersion.initial(), // Dummy version
-                scopeId = scopeId,
-                title = validatedTitle,
-                description = validatedDescription,
-                parentId = parentId,
-            )
-
-            val pendingEvents = listOf(EventEnvelope.Pending(event))
-
-            // Evolve phase - apply events to aggregate
-            val evolvedAggregate = initialAggregate.evolveWithPending(pendingEvents)
-
-            AggregateResult(
-                aggregate = evolvedAggregate,
-                events = pendingEvents,
-                baseVersion = AggregateVersion.initial(),
-            )
-        }
 
         /**
          * Creates an empty aggregate for event replay.
          * Used when loading an aggregate from the event store.
          */
-        fun empty(aggregateId: AggregateId): ScopeAggregate = ScopeAggregate(
-            id = aggregateId,
+        fun empty(scopeId: ScopeId, aggregateId: AggregateId): ScopeAggregate = ScopeAggregate(
+            _id = scopeId,
+            aggregateId = aggregateId,
             version = AggregateVersion.initial(),
             createdAt = Instant.DISTANT_PAST,
             updatedAt = Instant.DISTANT_PAST,
@@ -182,7 +181,7 @@ data class ScopeAggregate(
         }
 
         val event = ScopeTitleUpdated(
-            aggregateId = id,
+            aggregateId = aggregateId,
             eventId = EventId.generate(),
             occurredAt = now,
 
@@ -195,64 +194,6 @@ data class ScopeAggregate(
         this@ScopeAggregate.raiseEvent(event)
     }
 
-    /**
-     * Decides whether to update the title (decide phase).
-     * Returns pending events or empty list if no change needed.
-     */
-    fun decideUpdateTitle(title: String, now: Instant = Clock.System.now()): Either<ScopesError, List<EventEnvelope.Pending<ScopeEvent>>> = either {
-        val currentScope = scope
-        ensureNotNull(currentScope) {
-            ScopeError.NotFound(ScopeId.create(id.value.substringAfterLast("/")).bind())
-        }
-        ensure(!isDeleted) {
-            ScopeError.AlreadyDeleted(currentScope.id)
-        }
-
-        val newTitle = ScopeTitle.create(title).bind()
-        if (currentScope.title == newTitle) {
-            return@either emptyList()
-        }
-
-        val event = ScopeTitleUpdated(
-            aggregateId = id,
-            eventId = EventId.generate(),
-            occurredAt = now,
-
-            aggregateVersion = AggregateVersion.initial(), // Dummy version
-            scopeId = currentScope.id,
-            oldTitle = currentScope.title,
-            newTitle = newTitle,
-        )
-
-        listOf(EventEnvelope.Pending(event))
-    }
-
-    /**
-     * Handles update title command using decide/evolve pattern.
-     * Returns an AggregateResult with the updated aggregate and pending events.
-     */
-    fun handleUpdateTitle(title: String, now: Instant = Clock.System.now()): Either<ScopesError, AggregateResult<ScopeAggregate, ScopeEvent>> = either {
-        val pendingEvents = decideUpdateTitle(title, now).bind()
-
-        if (pendingEvents.isEmpty()) {
-            return@either AggregateResult(
-                aggregate = this@ScopeAggregate,
-                events = emptyList(),
-                baseVersion = version,
-            )
-        }
-
-        // Evolve phase - apply events to aggregate
-        val evolvedAggregate = pendingEvents.fold(this@ScopeAggregate) { agg, envelope ->
-            agg.applyEvent(envelope.event)
-        }
-
-        AggregateResult(
-            aggregate = evolvedAggregate,
-            events = pendingEvents,
-            baseVersion = version,
-        )
-    }
 
     /**
      * Updates the scope description after validation.
@@ -272,7 +213,7 @@ data class ScopeAggregate(
         }
 
         val event = ScopeDescriptionUpdated(
-            aggregateId = id,
+            aggregateId = aggregateId,
             eventId = EventId.generate(),
             occurredAt = now,
 
@@ -303,7 +244,7 @@ data class ScopeAggregate(
         }
 
         val event = ScopeParentChanged(
-            aggregateId = id,
+            aggregateId = aggregateId,
             eventId = EventId.generate(),
             occurredAt = now,
 
@@ -330,7 +271,7 @@ data class ScopeAggregate(
         }
 
         val event = ScopeDeleted(
-            aggregateId = id,
+            aggregateId = aggregateId,
             eventId = EventId.generate(),
             occurredAt = now,
 
@@ -358,7 +299,7 @@ data class ScopeAggregate(
         }
 
         val event = ScopeArchived(
-            aggregateId = id,
+            aggregateId = aggregateId,
             eventId = EventId.generate(),
             occurredAt = now,
 
@@ -386,7 +327,7 @@ data class ScopeAggregate(
         }
 
         val event = ScopeRestored(
-            aggregateId = id,
+            aggregateId = aggregateId,
             eventId = EventId.generate(),
             occurredAt = now,
 
@@ -405,7 +346,7 @@ data class ScopeAggregate(
      * We don't use event.aggregateVersion directly, but instead
      * increment based on the number of events applied.
      */
-    override fun applyEvent(event: ScopeEvent): ScopeAggregate = when (event) {
+    fun applyEvent(event: ScopeEvent): ScopeAggregate = when (event) {
         is ScopeCreated -> copy(
             version = version.increment(),
             createdAt = event.occurredAt,