chore: record pre-existing uncommitted repository state

Snapshot of the in-flight state that already existed, identically, in both
this worktree and the main checkout before this session began: the initial
HTTP Client platform implementation (previously untracked), the redis-lab
removal, and the JPA / object-storage / notification integration work.

Kept separate from this session's HTTP Client review response, which lands
in the following commit, so the two bodies of work stay reviewable apart.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

src/settings.gradle

@@ -16,9 +16,23 @@ def moduleRegistry = new JsonSlurper().parse(moduleRegistryFile)
 if (!(moduleRegistry instanceof Map)) {
     throw new GradleException("Module registry root must be a JSON object: ${moduleRegistryFile}")
 }
+Set<String> expectedRootFields = ['runtime_compositions', 'modules'] as Set
+if (moduleRegistry.keySet().collect { it as String }.toSet() != expectedRootFields) {
+    throw new GradleException(
+            "Module registry root fields must be exactly ${expectedRootFields}: ${moduleRegistryFile}")
+}
 if (!(moduleRegistry.modules instanceof List) || moduleRegistry.modules.isEmpty()) {
     throw new GradleException("Module registry has no modules: ${moduleRegistryFile}")
 }
+Set<String> expectedRuntimeCompositions = ['app-bootstrap', 'sample-portfolio'] as Set
+if (!(moduleRegistry.runtime_compositions instanceof List) ||
+        moduleRegistry.runtime_compositions.collect { it as String }.toSet() !=
+                expectedRuntimeCompositions ||
+        moduleRegistry.runtime_compositions.size() != expectedRuntimeCompositions.size()) {
+    throw new GradleException(
+            "Module registry runtime_compositions must be exactly ${expectedRuntimeCompositions}: " +
+                    moduleRegistryFile)
+}
 
 int expectedModuleCount = 19
 if (moduleRegistry.modules.size() != expectedModuleCount) {
@@ -38,6 +52,17 @@ List<Map<String, Object>> validatedModules = moduleRegistry.modules.withIndex().
     }
 
     Map<String, Object> module = rawModule as Map<String, Object>
+    Set<String> expectedModuleFields = [
+            'id',
+            'gradle_path',
+            'source_path',
+            'allowed_dependencies',
+            'runtime_memberships'
+    ] as Set
+    if (module.keySet().collect { it as String }.toSet() != expectedModuleFields) {
+        throw new GradleException(
+                "Module registry entry ${index} fields must be exactly ${expectedModuleFields}.")
+    }
     ['id', 'gradle_path', 'source_path'].each { field ->
         if (!(module[field] instanceof String) || (module[field] as String).isBlank()) {
             throw new GradleException(
@@ -48,6 +73,10 @@ List<Map<String, Object>> validatedModules = moduleRegistry.modules.withIndex().
         throw new GradleException(
                 "Module registry entry '${module.id}' needs an 'allowed_dependencies' list.")
     }
+    if (!(module.runtime_memberships instanceof List)) {
+        throw new GradleException(
+                "Module registry entry '${module.id}' needs a 'runtime_memberships' list.")
+    }
 
     String id = module.id as String
     String gradlePath = module.gradle_path as String
@@ -61,6 +90,25 @@ List<Map<String, Object>> validatedModules = moduleRegistry.modules.withIndex().
             }
             dependencyId as String
     }
+    List<String> runtimeMemberships = module.runtime_memberships.withIndex().collect {
+        membership, membershipIndex ->
+            if (!(membership instanceof String) || (membership as String).isBlank()) {
+                throw new GradleException(
+                        "Module registry entry '${id}' has a non-string or blank runtime membership " +
+                                "at index ${membershipIndex}.")
+            }
+            membership as String
+    }
+    if (runtimeMemberships.toSet().size() != runtimeMemberships.size()) {
+        throw new GradleException(
+                "Module registry entry '${id}' contains duplicate runtime memberships.")
+    }
+    Set<String> unknownRuntimeMemberships = runtimeMemberships.toSet() - expectedRuntimeCompositions
+    if (!unknownRuntimeMemberships.isEmpty()) {
+        throw new GradleException(
+                "Module registry entry '${id}' references unknown runtime memberships " +
+                        "${unknownRuntimeMemberships.toSorted()}.")
+    }
 
     if (!moduleIds.add(id)) {
         throw new GradleException("Module registry contains duplicate module id '${id}'.")
@@ -96,10 +144,20 @@ List<Map<String, Object>> validatedModules = moduleRegistry.modules.withIndex().
             id                  : id,
             gradle_path         : gradlePath,
             source_directory    : sourceDirectory,
-            allowed_dependencies: allowedDependencies
+            allowed_dependencies: allowedDependencies,
+            runtime_memberships : runtimeMemberships
     ]
 }
 
+expectedRuntimeCompositions.each { compositionId ->
+    Map<String, Object> composition = validatedModules.find { it.id == compositionId }
+    if (composition == null || !(composition.runtime_memberships as List).contains(compositionId)) {
+        throw new GradleException(
+                "Runtime composition '${compositionId}' must be registered and include itself in " +
+                        'runtime_memberships.')
+    }
+}
+
 validatedModules.each { module ->
     module.allowed_dependencies.each { dependencyId ->
         if (dependencyId == module.id) {