feat: refactor to a core lib

Author: josh-tracey

.env.example

@@ -32,24 +32,3 @@ jobs:
 
       - name: Run tests
         run: cargo test --workspace --all-targets --quiet
-
-  ui-build:
-    name: UI Build
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: '20'
-          cache: 'npm'
-          cache-dependency-path: 'rain-engine-ui/package-lock.json'
-          
-      - name: Install dependencies
-        working-directory: ./rain-engine-ui
-        run: npm ci || npm install
-        
-      - name: Build UI
-        working-directory: ./rain-engine-ui
-        run: npm run build

.github/workflows/ci.yml

@@ -2,10 +2,8 @@
 members = [
     "rain-engine-blob",
     "rain-engine-channels",
-    "rain-engine-cli",
     "rain-engine-cognition",
     "rain-engine-core",
-    "rain-engine-gateway",
     "rain-engine-ingress",
     "rain-engine-macros",
     "rain-engine-memory",
@@ -46,7 +44,6 @@ headless_chrome = "1.0.21"
 tokio = { version = "1", features = ["macros", "rt-multi-thread", "sync", "time", "net", "process", "io-util", "signal"] }
 tokio-util = "0.7"
 tower = { version = "0.5", features = ["util"] }
-tower-http = { version = "0.6", features = ["cors"] }
 tracing = "0.1"
 tracing-subscriber = { version = "0.3", features = ["fmt", "env-filter"] }
 url = "2"
@@ -56,7 +53,6 @@ wat = "1"
 quote = "1"
 proc-macro2 = "1"
 redis = { version = "0.32.7", features = ["aio", "tokio-comp"] }
-serde_yaml = "0.9"
 typeshare = "1"
 
 [package]
@@ -65,7 +61,7 @@ version.workspace = true
 edition.workspace = true
 license.workspace = true
 description = "An event-sourced Rust kernel for building durable AI agent systems"
-repository = "https://github.com/peter-steinberger/rain-engine" # Example placeholder
+repository = "https://github.com/Adriftdev/rain-engine"
 
 [features]
 default = ["server", "client", "sqlite", "gemini"]

Cargo.lock

@@ -1,7 +1,7 @@
 # RainEngine
 
-RainEngine is a self-improving, event-sourced Rust kernel for building durable
-AI agent systems.
+RainEngine is a self-improving, event-sourced Rust library workspace for
+building durable AI agent systems.
 
 The core idea is simple: an agent is a state machine backed by an append-only
 ledger. Every webhook, human message, scheduled wake, approval, delegation
@@ -19,23 +19,19 @@ visible, auditable, and never grants new power silently.
 - `rain-engine-core`: provider-neutral event kernel, domain models, policies, traits, ledger projections, and in-memory stores
 - `rain-engine-cognition`: optional planners, task routing, review policy, wake policy, and reflection policy
 - `rain-engine-memory`: ledger-backed exact replay, recent working sets, graph lookup, and simple semantic retrieval
-- `rain-engine-runtime`: reference Axum runtime that parses events and owns the advance loop
-- `rain-engine-gateway`: batteries-included gateway that wires runtime, built-in skills, channels, and wake handling
-- `rain-engine-ui`: Solid/Vite control room for live session inspection and human approval
-- `rain-engine-client`: Rust client for gateway integrations
-- `sdk/typescript`: TypeScript SDK for browser and Node clients
+- `rain-engine-runtime`: reference Axum runtime library that parses events and owns the advance loop
+- `rain-engine-client`: Rust client for runtime integrations
 - `rain-engine-ingress`: shared event envelope and Valkey Streams worker utilities
 - `rain-engine-blob`: local and in-memory blob stores for multimodal attachments
 - `rain-engine-wasm`: Wasmtime executor for untrusted skills with explicit host capabilities
 - `rain-engine-macros`: `#[derive(SkillManifest)]` for typed skill manifests
-- `rain-engine-skills`: built-in trusted native skills for local development and gateway deployments
+- `rain-engine-skills`: built-in trusted native skills for local development and runtime-backed deployments
 - `rain-engine-channels`: channel adapters that translate external messages into kernel events
 - `rain-engine-provider-gemini`: Gemini REST provider with multimodal content, parallel tool calls, and cache metadata
 - `rain-engine-openai`: OpenAI-compatible baseline provider
 - `rain-engine-store-pg`: Postgres append-only ledger store
 - `rain-engine-store-sqlite`: SQLite ledger store for local development and tests
 - `rain-engine-store-valkey`: Valkey coordination claims and short-lived scratchpad storage
-- `rain-engine-cli`: declarative `agent.yaml` validation and runtime bootstrapping
 
 ## Architecture
 
@@ -101,37 +97,13 @@ Guardrails are explicit:
 - regressions create rollback records and remove the overlay from future
   effective policy
 
-## Control Room
+## Library Surface
 
-RainEngine includes a web control room for operating the kernel through the
-server-client contract. The UI connects to the gateway, streams session updates
-over server-sent events, and renders the ledger as a live workbench:
-
-- session status, provider capabilities, and registered tools
-- human input and assistant outcomes
-- reasoning plans, tool execution graphs, checkpoints, validation failures, and
-  tool results
-- approval checkpoints with exact arguments and structured approve/deny actions
-- learning events, active policy overlays, reflections, and rollback history
-- projected goals, tasks, observations, artifacts, and raw records
-
-Start the development gateway:
-
-```bash
-cargo run -p rain-engine-cli -- dev
-```
-
-Then run the UI:
-
-```bash
-cd rain-engine-ui
-npm install
-npm run dev
-```
-
-The runtime exposes `GET /capabilities`, `GET /sessions/{id}/view`, and
-`GET /sessions/{id}/stream` so other clients can build the same control surface
-without depending on UI internals.
+RainEngine intentionally stops at reusable libraries. There are no first-party
+CLI, standalone daemon binary, or browser UI surfaces in this repository. The runtime,
+client, ingress, store, and provider crates are intended to be embedded in
+other systems that provide their own process model, configuration UX, and
+operator tooling.
 
 ## State Model
 
@@ -151,14 +123,11 @@ must be rebuildable from stored records.
 
 - Embedded SQLite flow: [embedded_sqlite.rs](/Users/adrift/projects/rain-engine/rain-engine-runtime/examples/embedded_sqlite.rs)
 - Runtime bootstrap config: [runtime_postgres.rs](/Users/adrift/projects/rain-engine/rain-engine-runtime/examples/runtime_postgres.rs)
-- Customer support deployment sketch: [customer_support_agent.rs](/Users/adrift/projects/rain-engine/rain-engine-cli/examples/customer_support_agent.rs)
-- Declarative deployment config: [agent.yaml](/Users/adrift/projects/rain-engine/rain-engine-cli/examples/agent.yaml)
 
 ## Verification
 
 ```bash
 cargo fmt
 cargo clippy --workspace --all-targets
 cargo test --workspace --all-targets --quiet
-cd rain-engine-ui && npm run build
 ```

Cargo.toml

@@ -6,6 +6,7 @@ license.workspace = true
 
 [dependencies]
 async-trait.workspace = true
+axum.workspace = true
 rain-engine-client = { path = "../rain-engine-client" }
 reqwest = { workspace = true }
 serde.workspace = true

README.md

@@ -1,4 +1,4 @@
-//! Discord bot adapter using REST gateway interactions.
+//! Discord bot adapter using runtime delivery plus Discord Gateway events.
 //!
 //! Requires `DISCORD_BOT_TOKEN` to be set.
 //! This adapter uses the Discord Gateway (WebSocket) for receiving messages
@@ -21,7 +21,7 @@ pub struct DiscordAdapter {
 impl DiscordAdapter {
     pub fn new(token: String, config: ChannelConfig) -> Self {
         Self {
-            engine_client: RainEngineClient::new(&config.gateway_url)
+            engine_client: RainEngineClient::new(&config.runtime_url)
                 .expect("failed to init client"),
             client: reqwest::Client::new(),
             token,

rain-engine-channels/Cargo.toml

@@ -13,8 +13,8 @@ use async_trait::async_trait;
 /// Configuration for a channel adapter.
 #[derive(Debug, Clone)]
 pub struct ChannelConfig {
-    /// Base URL of the RainEngine gateway.
-    pub gateway_url: String,
+    /// Base URL of the RainEngine runtime HTTP surface.
+    pub runtime_url: String,
     /// Session ID to use (or derive from platform user ID).
     pub default_session_prefix: String,
 }

rain-engine-channels/src/discord.rs

@@ -6,8 +6,11 @@
 
 use crate::{ChannelAdapter, ChannelConfig};
 use async_trait::async_trait;
+use axum::{Json, Router, extract::State, http::StatusCode, routing::post};
 use rain_engine_client::RainEngineClient;
 use serde::Deserialize;
+use serde_json::json;
+use std::sync::Arc;
 use tracing::{error, info, warn};
 
 #[derive(Debug, Clone)]
@@ -30,7 +33,7 @@ impl SlackAdapter {
         config: ChannelConfig,
     ) -> Self {
         Self {
-            engine_client: RainEngineClient::new(&config.gateway_url)
+            engine_client: RainEngineClient::new(&config.runtime_url)
                 .expect("failed to init client"),
             client: reqwest::Client::new(),
             bot_token,
@@ -124,22 +127,57 @@ impl ChannelAdapter for SlackAdapter {
             port = self.listen_port,
             "Slack adapter started — listening for Events API"
         );
+        warn!("Slack request signature verification is not enforced yet");
 
-        // In production this would spin up a small axum server to receive
-        // Slack Event API POSTs. For now, the structural skeleton is in place.
-        // The handle_event_message method is fully wired and ready.
-        //
-        // Integration pattern:
-        // 1. Slack sends POST to http://your-server:{port}/slack/events
-        // 2. We parse the SlackEventPayload
-        // 3. For url_verification: return { challenge }
-        // 4. For event_callback with message type: call handle_event_message
-        warn!(
-            "Slack adapter: Events API HTTP listener not yet started. Use handle_event_message() for integration."
-        );
+        let app = Router::new()
+            .route("/slack/events", post(handle_events))
+            .with_state(Arc::new(self.clone()));
+
+        let listener = match tokio::net::TcpListener::bind(("0.0.0.0", self.listen_port)).await {
+            Ok(listener) => listener,
+            Err(err) => {
+                error!("Slack adapter failed to bind: {err}");
+                return;
+            }
+        };
+
+        if let Err(err) = axum::serve(listener, app)
+            .with_graceful_shutdown(async move { cancel.cancelled().await })
+            .await
+        {
+            error!("Slack adapter listener error: {err}");
+        }
 
-        // Keep alive until cancelled
-        cancel.cancelled().await;
         info!("Slack adapter shutting down");
     }
 }
+
+async fn handle_events(
+    State(adapter): State<Arc<SlackAdapter>>,
+    Json(payload): Json<SlackEventPayload>,
+) -> Result<Json<serde_json::Value>, StatusCode> {
+    match payload.r#type.as_str() {
+        "url_verification" => {
+            let challenge = payload.challenge.unwrap_or_default();
+            Ok(Json(json!({ "challenge": challenge })))
+        }
+        "event_callback" => {
+            if let Some(event) = payload.event {
+                let is_supported_message =
+                    event.r#type == "message" || event.r#type == "app_mention";
+                if is_supported_message
+                    && let (Some(channel), Some(user), Some(text)) = (
+                        event.channel.as_deref(),
+                        event.user.as_deref(),
+                        event.text.as_deref(),
+                    )
+                    && event.bot_id.is_none()
+                {
+                    adapter.handle_event_message(channel, user, text).await;
+                }
+            }
+            Ok(Json(json!({ "ok": true })))
+        }
+        _ => Ok(Json(json!({ "ok": true }))),
+    }
+}

rain-engine-channels/src/lib.rs

@@ -19,7 +19,7 @@ pub struct TelegramAdapter {
 impl TelegramAdapter {
     pub fn new(token: String, config: ChannelConfig) -> Self {
         Self {
-            engine_client: RainEngineClient::new(&config.gateway_url)
+            engine_client: RainEngineClient::new(&config.runtime_url)
                 .expect("failed to init client"),
             client: reqwest::Client::new(),
             token,