feat: migrate channel routing to SettingsStore with hot-reload

- Add load_from_store/save_to_store for database-backed config
- Change AgentDeps.channel_routing to Arc<RwLock<Option<...>>> for hot-reload
- Make apply_channel_routing async to support RwLock reads
- Load from DB first, fallback to channel-routing.json file
- Update all test files for new RwLock type

Architecture change requested by ilblackdragon: config now uses the
SettingsStore system, enabling web UI configuration and hot-reload
without restarts.

Author: nick-stebbings

src/agent/agent_loop.rs

@@ -148,8 +148,9 @@ pub struct AgentDeps {
     pub document_extraction: Option<Arc<crate::document_extraction::DocumentExtractionMiddleware>>,
     /// Software builder for self-repair tool rebuilding.
     pub builder: Option<Arc<dyn crate::tools::SoftwareBuilder>>,
-    /// Per-channel tool routing config (loaded from channel-routing.json).
-    pub channel_routing: Option<Arc<crate::agent::channel_routing::ChannelRoutingConfig>>,
+    /// Per-channel tool routing config. Wrapped in RwLock for hot-reload support.
+    pub channel_routing:
+        Arc<tokio::sync::RwLock<Option<crate::agent::channel_routing::ChannelRoutingConfig>>>,
 }
 
 /// The main agent that coordinates all components.

src/agent/channel_routing.rs

@@ -9,6 +9,7 @@ use std::path::Path;
 
 use serde::{Deserialize, Serialize};
 
+use crate::db::SettingsStore;
 use crate::llm::ToolDefinition;
 
 /// Channel-to-tool-group routing configuration.
@@ -71,6 +72,59 @@ impl ChannelRoutingConfig {
         }
     }
 
+    /// Load from database-backed SettingsStore. Falls back to file if not in DB.
+    ///
+    /// This provides hot-reload support — the settings system handles cache
+    /// invalidation and the web UI can modify the config without restarts.
+    pub async fn load_from_store(
+        store: &(dyn SettingsStore + Send + Sync),
+        user_id: &str,
+        file_fallback: &Path,
+    ) -> Option<Self> {
+        match store.get_setting(user_id, "channel_routing").await {
+            Ok(Some(value)) => match serde_json::from_value::<Self>(value) {
+                Ok(config) => {
+                    if let Err(e) = config.validate() {
+                        tracing::error!("Channel routing config from DB invalid: {}", e);
+                        return None;
+                    }
+                    tracing::info!(
+                        groups = ?config.groups.keys().collect::<Vec<_>>(),
+                        channels = config.channels.len(),
+                        "Loaded channel routing config from database"
+                    );
+                    return Some(config);
+                }
+                Err(e) => {
+                    tracing::warn!("Failed to parse channel routing from DB: {}", e);
+                }
+            },
+            Ok(None) => {
+                tracing::debug!("No channel routing config in database, trying file fallback");
+            }
+            Err(e) => {
+                tracing::warn!("Failed to read channel routing from DB: {}", e);
+            }
+        }
+        // Fall back to file-based config
+        Self::load(file_fallback)
+    }
+
+    /// Save current config to the database SettingsStore.
+    pub async fn save_to_store(
+        &self,
+        store: &(dyn SettingsStore + Send + Sync),
+        user_id: &str,
+    ) -> Result<(), crate::error::DatabaseError> {
+        let value = serde_json::to_value(self).map_err(|e| {
+            crate::error::DatabaseError::Serialization(format!(
+                "Failed to serialize channel routing: {}",
+                e
+            ))
+        })?;
+        store.set_setting(user_id, "channel_routing", &value).await
+    }
+
     /// Validate that group references are consistent.
     fn validate(&self) -> Result<(), String> {
         // default_group must exist in groups

src/agent/dispatcher.rs

@@ -35,12 +35,13 @@ pub(super) enum AgenticLoopResult {
 
 impl Agent {
     /// Apply per-channel tool filtering if routing config is loaded.
-    fn apply_channel_routing(
+    async fn apply_channel_routing(
         &self,
         channel: &str,
         tools: Vec<crate::llm::ToolDefinition>,
     ) -> Vec<crate::llm::ToolDefinition> {
-        if let Some(ref routing) = self.deps.channel_routing {
+        let guard = self.deps.channel_routing.read().await;
+        if let Some(ref routing) = *guard {
             let before = tools.len();
             let filtered = routing.filter_tool_defs(channel, tools);
             if filtered.len() < before {
@@ -178,7 +179,9 @@ impl Agent {
         // Build system prompts once for this turn. Two variants: with tools
         // (normal iterations) and without (force_text final iteration).
         let initial_tool_defs = self.tools().tool_definitions().await;
-        let initial_tool_defs = self.apply_channel_routing(&message.channel, initial_tool_defs);
+        let initial_tool_defs = self
+            .apply_channel_routing(&message.channel, initial_tool_defs)
+            .await;
         let initial_tool_defs = if !active_skills.is_empty() {
             crate::skills::attenuate_tools(&initial_tool_defs, &active_skills).tools
         } else {
@@ -313,7 +316,8 @@ impl<'a> LoopDelegate for ChatDelegate<'a> {
         let tool_defs = self.agent.tools().tool_definitions().await;
         let tool_defs = self
             .agent
-            .apply_channel_routing(&self.message.channel, tool_defs);
+            .apply_channel_routing(&self.message.channel, tool_defs)
+            .await;
 
         // Apply trust-based tool attenuation if skills are active.
         let tool_defs = if !self.active_skills.is_empty() {
@@ -1226,7 +1230,7 @@ mod tests {
             transcription: None,
             document_extraction: None,
             builder: None,
-            channel_routing: None,
+            channel_routing: std::sync::Arc::new(tokio::sync::RwLock::new(None)),
         };
 
         Agent::new(
@@ -2068,7 +2072,7 @@ mod tests {
             transcription: None,
             document_extraction: None,
             builder: None,
-            channel_routing: None,
+            channel_routing: std::sync::Arc::new(tokio::sync::RwLock::new(None)),
         };
 
         Agent::new(
@@ -2188,7 +2192,7 @@ mod tests {
                 transcription: None,
                 document_extraction: None,
                 builder: None,
-                channel_routing: None,
+                channel_routing: std::sync::Arc::new(tokio::sync::RwLock::new(None)),
             };
 
             Agent::new(

src/main.rs

@@ -718,6 +718,21 @@ async fn async_main() -> anyhow::Result<()> {
     // Clone context_manager for the reaper before it's moved into Agent::new()
     let reaper_context_manager = Arc::clone(&components.context_manager);
 
+    // Load channel routing config before components.db is moved
+    let channel_routing_config = {
+        let base_dir = ironclaw::bootstrap::ironclaw_base_dir();
+        if let Some(ref db) = components.db {
+            ironclaw::agent::channel_routing::ChannelRoutingConfig::load_from_store(
+                db.as_ref(),
+                "default",
+                &base_dir,
+            )
+            .await
+        } else {
+            ironclaw::agent::channel_routing::ChannelRoutingConfig::load(&base_dir)
+        }
+    };
+
     // Capture db reference for SIGHUP handler before it's moved into AgentDeps (Unix only)
     #[cfg(unix)]
     let sighup_settings_store: Option<Arc<dyn ironclaw::db::SettingsStore>> = components
@@ -749,10 +764,7 @@ async fn async_main() -> anyhow::Result<()> {
             ironclaw::document_extraction::DocumentExtractionMiddleware::new(),
         )),
         builder: components.builder,
-        channel_routing: ironclaw::agent::channel_routing::ChannelRoutingConfig::load(
-            &ironclaw::bootstrap::ironclaw_base_dir(),
-        )
-        .map(Arc::new),
+        channel_routing: Arc::new(tokio::sync::RwLock::new(channel_routing_config)),
     };
 
     let mut agent = Agent::new(

src/testing/mod.rs

@@ -493,7 +493,7 @@ impl TestHarnessBuilder {
             transcription: None,
             document_extraction: None,
             builder: None,
-            channel_routing: None,
+            channel_routing: std::sync::Arc::new(tokio::sync::RwLock::new(None)),
         };
 
         TestHarness {

tests/e2e_telegram_message_routing.rs

@@ -199,7 +199,7 @@ mod tests {
             transcription: None,
             document_extraction: None,
             builder: None,
-            channel_routing: None,
+            channel_routing: std::sync::Arc::new(tokio::sync::RwLock::new(None)),
         };
 
         let gateway = Arc::new(TestChannel::new());

tests/support/gateway_workflow_harness.rs

@@ -258,7 +258,7 @@ impl GatewayWorkflowHarness {
                 transcription: None,
                 document_extraction: None,
                 builder: None,
-                channel_routing: None,
+                channel_routing: std::sync::Arc::new(tokio::sync::RwLock::new(None)),
             },
             channels,
             None,

tests/support/test_rig.rs

@@ -643,7 +643,7 @@ impl TestRigBuilder {
             transcription: None,
             document_extraction: None,
             builder: None,
-            channel_routing: None,
+            channel_routing: std::sync::Arc::new(tokio::sync::RwLock::new(None)),
         };
 
         // 7. Create TestChannel and ChannelManager.