refactor: remove redundant jMolecules comments and improve ID extraction

contexts/device-synchronization/domain/src/main/kotlin/io/github/kamiazya/scopes/devicesync/domain/entity/SyncConflict.kt

@@ -1,17 +1,21 @@
 package io.github.kamiazya.scopes.devicesync.domain.entity
 
+import io.github.kamiazya.scopes.devicesync.domain.valueobject.ConflictId
 import io.github.kamiazya.scopes.devicesync.domain.valueobject.ConflictType
 import io.github.kamiazya.scopes.devicesync.domain.valueobject.ResolutionAction
 import io.github.kamiazya.scopes.devicesync.domain.valueobject.VectorClock
 import kotlinx.datetime.Instant
+import org.jmolecules.ddd.types.Entity
 
 /**
  * Represents a synchronization conflict with rich domain logic for resolution.
  *
  * This entity encapsulates the business rules for conflict detection, analysis,
  * and resolution strategies.
+ *
  */
 data class SyncConflict(
+    private val _id: ConflictId,
     val localEventId: String,
     val remoteEventId: String,
     val aggregateId: String,
@@ -23,7 +27,13 @@ data class SyncConflict(
     val detectedAt: Instant,
     val resolvedAt: Instant? = null,
     val resolution: ResolutionAction? = null,
-) {
+) : Entity<SyncState, ConflictId> {
+
+    /**
+     * Use getId() to access the conflict ID.
+     */
+    override fun getId(): ConflictId = _id
+
     init {
         require(localEventId.isNotBlank()) { "Local event ID cannot be blank" }
         require(remoteEventId.isNotBlank()) { "Remote event ID cannot be blank" }
@@ -180,6 +190,7 @@ data class SyncConflict(
             require(remoteVersion >= 0) { "Remote version must be non-negative" }
 
             return SyncConflict(
+                _id = ConflictId.generate(),
                 localEventId = localEventId,
                 remoteEventId = remoteEventId,
                 aggregateId = aggregateId,
@@ -191,6 +202,37 @@ data class SyncConflict(
                 detectedAt = detectedAt,
             )
         }
+
+        /**
+         * Create a new SyncConflict for testing purposes.
+         * Auto-generates an ID.
+         */
+        fun create(
+            localEventId: String,
+            remoteEventId: String,
+            aggregateId: String,
+            localVersion: Long,
+            remoteVersion: Long,
+            localVectorClock: VectorClock,
+            remoteVectorClock: VectorClock,
+            conflictType: ConflictType,
+            detectedAt: Instant,
+            resolvedAt: Instant? = null,
+            resolution: ResolutionAction? = null,
+        ): SyncConflict = SyncConflict(
+            _id = ConflictId.generate(),
+            localEventId = localEventId,
+            remoteEventId = remoteEventId,
+            aggregateId = aggregateId,
+            localVersion = localVersion,
+            remoteVersion = remoteVersion,
+            localVectorClock = localVectorClock,
+            remoteVectorClock = remoteVectorClock,
+            conflictType = conflictType,
+            detectedAt = detectedAt,
+            resolvedAt = resolvedAt,
+            resolution = resolution,
+        )
     }
 }
 

contexts/device-synchronization/domain/src/main/kotlin/io/github/kamiazya/scopes/devicesync/domain/entity/SyncState.kt

@@ -3,23 +3,36 @@ package io.github.kamiazya.scopes.devicesync.domain.entity
 import io.github.kamiazya.scopes.devicesync.domain.valueobject.DeviceId
 import io.github.kamiazya.scopes.devicesync.domain.valueobject.VectorClock
 import kotlinx.datetime.Instant
+import org.jmolecules.ddd.types.AggregateRoot
 import kotlin.time.Duration
 
 /**
  * Represents the synchronization state between this device and another device.
  *
  * This entity encapsulates the business logic for managing synchronization state,
  * including state transitions, sync readiness checks, and error handling.
+ *
+ * Each SyncState is uniquely identified by the remote DeviceId it syncs with.
  */
 data class SyncState(
-    val deviceId: DeviceId,
+    private val _deviceId: DeviceId,
     val lastSyncAt: Instant?,
     val remoteVectorClock: VectorClock,
     val lastSuccessfulPush: Instant?,
     val lastSuccessfulPull: Instant?,
     val syncStatus: SyncStatus,
     val pendingChanges: Int = 0,
-) {
+) : AggregateRoot<SyncState, DeviceId> {
+
+    /**
+     */
+    override fun getId(): DeviceId = _deviceId
+
+    /**
+     * Public accessor for deviceId.
+     */
+    val deviceId: DeviceId
+        get() = _deviceId
     init {
         require(pendingChanges >= 0) { "Pending changes cannot be negative" }
         lastSuccessfulPush?.let { push ->

contexts/device-synchronization/domain/src/main/kotlin/io/github/kamiazya/scopes/devicesync/domain/valueobject/DeviceId.kt

@@ -1,15 +1,17 @@
 package io.github.kamiazya.scopes.devicesync.domain.valueobject
 
 import io.github.kamiazya.scopes.platform.commons.id.ULID
+import org.jmolecules.ddd.types.Identifier
 
 /**
  * Represents a unique identifier for a device in the multi-device synchronization system.
  *
  * Each device participating in synchronization has a unique ID that is used to track
  * which events originated from which device and to maintain vector clocks.
+ *
  */
 @JvmInline
-value class DeviceId(val value: String) {
+value class DeviceId(val value: String) : Identifier {
     init {
         require(value.isNotBlank()) { "Device ID cannot be blank" }
         require(value.length <= 64) { "Device ID cannot exceed 64 characters" }