Feature/channel integrations

docs/group-conversations.md

@@ -205,9 +205,49 @@ For full control, define phases directly:
 | `read_group_conversation` | Read conversation transcript |
 | `list_group_conversations` | List past discussions |
 
+## Slack Integration
+
+Group discussions integrate natively with Slack. See [slack-integration.md](slack-integration.md) for full setup instructions.
+
+### UX Pattern: Header + Thread
+
+All discussion styles use the same rendering pattern in Slack:
+
+1. **Start Banner** — posted in the user's thread with style name, agent count, and question
+2. **Agent Headers** — each agent's first contribution is a channel-level message with a short preview
+3. **Full Content** — the complete response is posted as a thread reply under the agent's header
+4. **Peer Feedback** — feedback threads under the target agent's header message
+5. **Revisions** — revised contributions thread under the agent's own header
+6. **Synthesis** — moderator's synthesis gets its own channel-level header + thread
+
+### Discussion Styles in Slack
+
+| Style | Phase Flow in Slack |
+|-------|-------------------|
+| **ROUND_TABLE** | Each agent posts → Moderator synthesizes |
+| **PEER_REVIEW** | Agents post → Critiques thread under targets → Revisions thread under own → Synthesis |
+| **DEVIL_ADVOCATE** | Agent posts → Challenger threads challenges → Agent threads defense → Synthesis |
+| **DEBATE** | PRO agent posts → CON agent posts → Rebuttals thread under opponents → Judge synthesizes |
+| **DELPHI** | Round 1 agents post → Round 2 agents post (convergence) → Synthesis |
+
+### Trigger Keywords
+
+Configure trigger keywords in `ChannelIntegrationConfiguration` to route to specific groups:
+
+```
+@EDDI panel: Should we adopt microservices?     → GROUP target "panel"
+@EDDI debate: REST vs GraphQL                   → GROUP target "debate"
+@EDDI peer: Review this architecture             → GROUP target "peer"
+```
+
+### Follow-up Conversations
+
+After a discussion, users can reply in any agent's thread to ask follow-up questions. The system injects the agent's discussion context (contribution + peer feedback received) into the prompt for a contextual response.
+
 ## Configuration
 
 ```properties
 # application.properties
 eddi.groups.max-depth=3    # Max recursion depth for nested groups
 ```
+

pom.xml

@@ -556,6 +556,10 @@
                          Prevents CI from hanging indefinitely when Docker image builds
                          or container startup fails to propagate errors. -->
                     <forkedProcessTimeoutInSeconds>900</forkedProcessTimeoutInSeconds>
+                    <!-- Retry container-startup failures once. Testcontainers ITs
+                         can flake on CI runners due to Docker networking timing.
+                         This gives one automatic retry before failing the build. -->
+                    <rerunFailingTestsCount>1</rerunFailingTestsCount>
                     <systemPropertyVariables>
                         <native.image.path>${project.build.directory}/${project.build.finalName}-runner
                         </native.image.path>

src/main/java/ai/labs/eddi/configs/agents/model/AgentConfiguration.java

@@ -19,6 +19,14 @@
 public class AgentConfiguration {
     @JsonAlias("packages")
     private List<URI> workflows = new ArrayList<>();
+    /**
+     * @deprecated Since 6.1.0. Use standalone
+     *             {@code ChannelIntegrationConfiguration} documents instead. Legacy
+     *             connectors are auto-migrated at startup by
+     *             {@code ChannelConnectorMigration}. This field will be removed in
+     *             a future release.
+     */
+    @Deprecated(since = "6.1.0", forRemoval = true)
     private List<ChannelConnector> channels = new ArrayList<>();
 
     /**
@@ -78,6 +86,11 @@ public class AgentConfiguration {
      */
     private SessionManagement sessionManagement;
 
+    /**
+     * @deprecated Since 6.1.0. Replaced by {@code ChannelIntegrationConfiguration}
+     *             with multi-target routing support.
+     */
+    @Deprecated(since = "6.1.0", forRemoval = true)
     public static class ChannelConnector {
         private URI type;
         private Map<String, String> config = new HashMap<>();
@@ -107,10 +120,12 @@ public void setWorkflows(List<URI> workflows) {
         this.workflows = workflows;
     }
 
+    @Deprecated(since = "6.1.0", forRemoval = true)
     public List<ChannelConnector> getChannels() {
         return channels;
     }
 
+    @Deprecated(since = "6.1.0", forRemoval = true)
     public void setChannels(List<ChannelConnector> channels) {
         this.channels = channels;
     }

src/main/java/ai/labs/eddi/configs/channels/IChannelIntegrationStore.java

@@ -0,0 +1,17 @@
+/*
+ * Copyright EDDI contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+package ai.labs.eddi.configs.channels;
+
+import ai.labs.eddi.configs.channels.model.ChannelIntegrationConfiguration;
+import ai.labs.eddi.datastore.IResourceStore;
+
+/**
+ * Store interface for channel integration configurations. Uses the DB-agnostic
+ * {@code AbstractResourceStore} via {@code IResourceStorageFactory}.
+ *
+ * @since 6.1.0
+ */
+public interface IChannelIntegrationStore extends IResourceStore<ChannelIntegrationConfiguration> {
+}

src/main/java/ai/labs/eddi/configs/channels/IRestChannelIntegrationStore.java

@@ -0,0 +1,86 @@
+/*
+ * Copyright EDDI contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+package ai.labs.eddi.configs.channels;
+
+import ai.labs.eddi.configs.IRestVersionInfo;
+import ai.labs.eddi.configs.channels.model.ChannelIntegrationConfiguration;
+import ai.labs.eddi.configs.descriptors.model.DocumentDescriptor;
+import jakarta.annotation.security.RolesAllowed;
+import jakarta.ws.rs.*;
+import jakarta.ws.rs.core.MediaType;
+import jakarta.ws.rs.core.Response;
+import org.eclipse.microprofile.openapi.annotations.Operation;
+import org.eclipse.microprofile.openapi.annotations.parameters.Parameter;
+import org.eclipse.microprofile.openapi.annotations.tags.Tag;
+
+import java.util.List;
+
+/**
+ * JAX-RS interface for channel integration configuration CRUD.
+ * <p>
+ * Admin-only — channel configurations expose target topology and vault
+ * references. Same security posture as {@code IRestAgentStore}.
+ *
+ * @since 6.1.0
+ */
+@Path("/channelstore/channels")
+@Tag(name = "Channel Integrations")
+@RolesAllowed({"eddi-admin", "eddi-editor"})
+public interface IRestChannelIntegrationStore extends IRestVersionInfo {
+    String resourceBaseType = "eddi://ai.labs.channel";
+    String resourceURI = resourceBaseType + "/channelstore/channels/";
+
+    @GET
+    @Path("/descriptors")
+    @Produces(MediaType.APPLICATION_JSON)
+    @Operation(description = "Read list of channel integration descriptors.")
+    List<DocumentDescriptor> readChannelDescriptors(
+                                                    @QueryParam("filter")
+                                                    @DefaultValue("") String filter,
+                                                    @QueryParam("index")
+                                                    @DefaultValue("0") Integer index,
+                                                    @QueryParam("limit")
+                                                    @DefaultValue("20") Integer limit);
+
+    @GET
+    @Path("/{id}")
+    @Produces(MediaType.APPLICATION_JSON)
+    @Operation(description = "Read channel integration configuration.")
+    ChannelIntegrationConfiguration readChannel(
+                                                @PathParam("id") String id,
+                                                @Parameter(name = "version", required = true, example = "1")
+                                                @QueryParam("version") Integer version);
+
+    @PUT
+    @Path("/{id}")
+    @Consumes(MediaType.APPLICATION_JSON)
+    @Operation(description = "Update channel integration configuration.")
+    Response updateChannel(
+                           @PathParam("id") String id,
+                           @Parameter(name = "version", required = true, example = "1")
+                           @QueryParam("version") Integer version,
+                           ChannelIntegrationConfiguration channelConfiguration);
+
+    @POST
+    @Consumes(MediaType.APPLICATION_JSON)
+    @Operation(description = "Create channel integration configuration.")
+    Response createChannel(ChannelIntegrationConfiguration channelConfiguration);
+
+    @POST
+    @Path("/{id}")
+    @Operation(description = "Duplicate this channel integration configuration.")
+    Response duplicateChannel(@PathParam("id") String id,
+                              @QueryParam("version") Integer version);
+
+    @DELETE
+    @Path("/{id}")
+    @Operation(description = "Delete channel integration configuration.")
+    Response deleteChannel(
+                           @PathParam("id") String id,
+                           @Parameter(name = "version", required = true, example = "1")
+                           @QueryParam("version") Integer version,
+                           @QueryParam("permanent")
+                           @DefaultValue("false") Boolean permanent);
+}

src/main/java/ai/labs/eddi/configs/channels/model/ChannelIntegrationConfiguration.java

@@ -0,0 +1,109 @@
+/*
+ * Copyright EDDI contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+package ai.labs.eddi.configs.channels.model;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Standalone configuration for a channel integration. Decouples channel routing
+ * and credentials from {@code AgentConfiguration}, supporting multi-target
+ * channels and cross-platform extensibility (Slack, Teams, Discord).
+ * <p>
+ * One {@code ChannelIntegrationConfiguration} represents one platform channel
+ * (e.g., a single Slack channel) with one or more {@link ChannelTarget}s that
+ * map trigger keywords to agents or groups.
+ *
+ * @since 6.1.0
+ */
+@JsonInclude(JsonInclude.Include.NON_NULL)
+public class ChannelIntegrationConfiguration {
+
+    private String name;
+    private String channelType;
+    private Map<String, String> platformConfig;
+    private List<ChannelTarget> targets;
+    private String defaultTargetName;
+
+    public ChannelIntegrationConfiguration() {
+        this.platformConfig = new HashMap<>();
+        this.targets = new ArrayList<>();
+    }
+
+    /**
+     * Human-readable name for this integration (e.g., "Engineering AI Hub").
+     */
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    /**
+     * Platform type. Validated server-side against registered adapters. Currently
+     * supported: {@code "slack"}. Future: {@code "teams"}, {@code "discord"}.
+     * <p>
+     * Deliberately a String (not an enum) so downstream forks can register custom
+     * adapters without recompiling core.
+     */
+    public String getChannelType() {
+        return channelType;
+    }
+
+    public void setChannelType(String channelType) {
+        this.channelType = channelType;
+    }
+
+    /**
+     * Platform-specific credentials and identifiers. Keys depend on
+     * {@link #channelType}:
+     * <ul>
+     * <li><b>slack:</b> {@code channelId}, {@code botToken},
+     * {@code signingSecret}</li>
+     * <li><b>teams:</b> {@code channelId}, {@code appId}, {@code appPassword},
+     * {@code serviceUrl}</li>
+     * <li><b>discord:</b> {@code guildId}, {@code channelId}, {@code botToken},
+     * {@code publicKey}</li>
+     * </ul>
+     * Secret values should use vault references: {@code ${vault:key-name}}.
+     */
+    public Map<String, String> getPlatformConfig() {
+        return new HashMap<>(platformConfig);
+    }
+
+    public void setPlatformConfig(Map<String, String> platformConfig) {
+        this.platformConfig = platformConfig == null ? new HashMap<>() : new HashMap<>(platformConfig);
+    }
+
+    /**
+     * Available targets in this channel. Each target maps trigger keywords to an
+     * agent or group. At least one target is required.
+     */
+    public List<ChannelTarget> getTargets() {
+        return new ArrayList<>(targets);
+    }
+
+    public void setTargets(List<ChannelTarget> targets) {
+        this.targets = targets == null ? new ArrayList<>() : new ArrayList<>(targets);
+    }
+
+    /**
+     * Name of the target to use when no trigger keyword matches. Must reference an
+     * existing target in {@link #targets}. Required.
+     */
+    public String getDefaultTargetName() {
+        return defaultTargetName;
+    }
+
+    public void setDefaultTargetName(String defaultTargetName) {
+        this.defaultTargetName = defaultTargetName;
+    }
+}