refactor: remove redundant jMolecules comments and improve ID extraction

.changeset/fix-release-workflow-heredoc-syntax.md

@@ -2,4 +2,4 @@
 "scopes": patch
 ---
 
-fix: Resolved a release workflow failure by correcting heredoc syntax in `release.yml` to prevent improper variable expansion.
+fix: Resolved a release workflow failure by correcting heredoc syntax in `release.yml` to prevent improper variable expansion.

.changeset/platform-bundle-packages.md

@@ -9,4 +9,4 @@ Replace the previous 28 individual release assets with organized bundle packages
 - 1 unified offline package (~260MB) for enterprise/multi-platform deployments
 - SLSA provenance for supply chain security
 
-This provides 92% reduction in download size for most users while maintaining all existing security features (SLSA Level 3, SHA256 verification) and preparing for future daemon binary distribution.
+This provides 92% reduction in download size for most users while maintaining all existing security features (SLSA Level 3, SHA256 verification) and preparing for future daemon binary distribution.

apps/scopes/build.gradle.kts

@@ -77,6 +77,9 @@ dependencies {
     testImplementation(libs.bundles.kotest)
     testImplementation(libs.mockk)
     testImplementation(libs.kotlinx.coroutines.test)
+
+    // jMolecules - DDD building blocks (needed for test compilation as tests use domain entities)
+    testImplementation(libs.jmolecules.ddd)
 }
 
 application {

apps/scopes/src/test/kotlin/io/github/kamiazya/scopes/apps/cli/integration/AspectQueryIntegrationTest.kt

@@ -17,7 +17,6 @@ import io.github.kamiazya.scopes.scopemanagement.domain.service.query.AspectQuer
 import io.github.kamiazya.scopes.scopemanagement.domain.valueobject.AspectKey
 import io.github.kamiazya.scopes.scopemanagement.domain.valueobject.AspectValue
 import io.github.kamiazya.scopes.scopemanagement.domain.valueobject.Aspects
-import io.github.kamiazya.scopes.scopemanagement.domain.valueobject.ScopeId
 import io.github.kamiazya.scopes.scopemanagement.domain.valueobject.ScopeTitle
 import io.github.kamiazya.scopes.scopemanagement.infrastructure.repository.InMemoryAspectDefinitionRepository
 import io.github.kamiazya.scopes.scopemanagement.infrastructure.repository.InMemoryScopeAliasRepository
@@ -113,8 +112,7 @@ class AspectQueryIntegrationTest :
                     aspectDefinitionRepository.save(timeDef)
 
                     // Create test scopes with aspects
-                    scope1 = Scope(
-                        id = ScopeId.generate(),
+                    scope1 = Scope.createForTest(
                         title = ScopeTitle.create("Task 1").getOrNull()!!,
                         description = null,
                         parentId = null,
@@ -137,8 +135,7 @@ class AspectQueryIntegrationTest :
                         aliasRepository = aliasRepository,
                     )
 
-                    scope2 = Scope(
-                        id = ScopeId.generate(),
+                    scope2 = Scope.createForTest(
                         title = ScopeTitle.create("Task 2").getOrNull()!!,
                         description = null,
                         parentId = null,
@@ -161,8 +158,7 @@ class AspectQueryIntegrationTest :
                         aliasRepository = aliasRepository,
                     )
 
-                    scope3 = Scope(
-                        id = ScopeId.generate(),
+                    scope3 = Scope.createForTest(
                         title = ScopeTitle.create("Task 3").getOrNull()!!,
                         description = null,
                         parentId = null,
@@ -185,8 +181,7 @@ class AspectQueryIntegrationTest :
                         aliasRepository = aliasRepository,
                     )
 
-                    scope4 = Scope(
-                        id = ScopeId.generate(),
+                    scope4 = Scope.createForTest(
                         title = ScopeTitle.create("Task 4").getOrNull()!!,
                         description = null,
                         parentId = null,

apps/scopes/src/test/kotlin/io/github/kamiazya/scopes/apps/cli/test/TestDataHelper.kt

@@ -1,7 +1,7 @@
 package io.github.kamiazya.scopes.apps.cli.test
 
+import io.github.kamiazya.scopes.scopemanagement.domain.aggregate.ScopeAlias
 import io.github.kamiazya.scopes.scopemanagement.domain.entity.Scope
-import io.github.kamiazya.scopes.scopemanagement.domain.entity.ScopeAlias
 import io.github.kamiazya.scopes.scopemanagement.domain.repository.ScopeAliasRepository
 import io.github.kamiazya.scopes.scopemanagement.domain.repository.ScopeRepository
 import io.github.kamiazya.scopes.scopemanagement.domain.valueobject.AliasName

build.gradle.kts

@@ -151,7 +151,7 @@ tasks.register("konsistTest") {
 configure<com.diffplug.gradle.spotless.SpotlessExtension> {
     kotlin {
         target("**/*.kt")
-        targetExclude("**/build/**/*.kt", "**/.tmp/**/*.kt")
+        targetExclude("**/build/**/*.kt", "**/.tmp/**/*.kt", "**/.gradle-local/**/*.kt")
         ktlint(
             libs.versions.ktlint.tool
                 .get(),
@@ -194,7 +194,7 @@ configure<com.diffplug.gradle.spotless.SpotlessExtension> {
     }
     format("markdown") {
         target("**/*.md")
-        targetExclude("**/build/**/*.md")
+        targetExclude("**/build/**/*.md", "**/tmp/**/*.md")
         endWithNewline()
         // Trailing whitespace has semantic meaning in Markdown, so follow .editorconfig
     }

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/package-info.kt

@@ -0,0 +1,21 @@
+@file:DomainLayer
+
+package io.github.kamiazya.scopes.devicesync.domain
+
+import org.jmolecules.architecture.layered.DomainLayer
+
+/**
+ * Device Synchronization domain package.
+ *
+ * This bounded context handles multi-device consistency and synchronization.
+ * It models vector clocks, sync states, conflicts, and the synchronization protocol.
+ *
+ * Domain Types:
+ * - DeviceId: Identifier for devices (jMolecules Identifier)
+ * - SyncState: Entity tracking synchronization state per device
+ * - SyncConflict: Entity representing detected conflicts
+ * - VectorClock: Value object for causal ordering
+ *
+ * Domain Services:
+ * - DeviceSynchronizationService: Core sync logic
+ */

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

@@ -0,0 +1,14 @@
+package io.github.kamiazya.scopes.devicesync.domain.valueobject
+
+import io.github.kamiazya.scopes.platform.commons.id.ULID
+import org.jmolecules.ddd.types.Identifier
+
+/**
+ * Identity for SyncConflict entity.
+ */
+@JvmInline
+value class ConflictId(val value: String) : Identifier {
+    companion object {
+        fun generate(): ConflictId = ConflictId(ULID.generate().value)
+    }
+}

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" }