huskies: merge 558_story_matrix_bot_can_run_on_the_gateway_to_manage_multiple_projects_from_one_chat

server/src/chat/transport/matrix/bot/context.rs

@@ -8,7 +8,7 @@ use std::collections::{HashMap, HashSet};
 use std::path::PathBuf;
 use std::sync::Arc;
 use tokio::sync::Mutex as TokioMutex;
-use tokio::sync::{mpsc, oneshot};
+use tokio::sync::{RwLock, mpsc, oneshot};
 
 use super::history::ConversationHistory;
 
@@ -59,6 +59,12 @@ pub struct BotContext {
     pub transport: Arc<dyn ChatTransport>,
     /// Persistent store for pending deferred-start timers.
     pub timer_store: Arc<TimerStore>,
+    /// In gateway mode: the currently active project (shared with the gateway HTTP handler).
+    /// `None` in standalone single-project mode.
+    pub gateway_active_project: Option<Arc<RwLock<String>>>,
+    /// In gateway mode: valid project names accepted by the `switch` command.
+    /// Empty in standalone mode.
+    pub gateway_projects: Vec<String>,
 }
 
 // ---------------------------------------------------------------------------
@@ -110,6 +116,8 @@ mod tests {
             timer_store: Arc::new(crate::chat::timer::TimerStore::load(
                 std::path::PathBuf::from("/tmp/timers.json"),
             )),
+            gateway_active_project: None,
+            gateway_projects: vec![],
         };
         // Clone must work (required by Matrix SDK event handler injection).
         let _cloned = ctx.clone();

server/src/chat/transport/matrix/bot/messages.rs

@@ -450,6 +450,47 @@ pub(super) async fn on_room_message(
         return;
     }
 
+    // In gateway mode, handle the "switch <project>" command to change the
+    // active project without invoking the LLM.
+    if let Some(ref active_project) = ctx.gateway_active_project {
+        let stripped = crate::chat::util::strip_bot_mention(
+            &user_message,
+            &ctx.bot_name,
+            ctx.bot_user_id.as_str(),
+        )
+        .trim()
+        .trim_start_matches(|c: char| !c.is_alphanumeric())
+        .to_string();
+
+        let (cmd, arg) = match stripped.split_once(char::is_whitespace) {
+            Some((c, a)) => (c.to_string(), a.trim().to_string()),
+            None => (stripped.clone(), String::new()),
+        };
+
+        if cmd.eq_ignore_ascii_case("switch") {
+            let response = if arg.is_empty() {
+                let available = ctx.gateway_projects.join(", ");
+                format!("Usage: `switch <project>`. Available projects: {available}")
+            } else if ctx.gateway_projects.iter().any(|p| p == &arg) {
+                *active_project.write().await = arg.clone();
+                format!("Switched to project **{arg}**.")
+            } else {
+                let available = ctx.gateway_projects.join(", ");
+                format!("Unknown project `{arg}`. Available: {available}")
+            };
+            let html = markdown_to_html(&response);
+            if let Ok(msg_id) = ctx
+                .transport
+                .send_message(&room_id_str, &response, &html)
+                .await
+                && let Ok(event_id) = msg_id.parse()
+            {
+                ctx.bot_sent_event_ids.lock().await.insert(event_id);
+            }
+            return;
+        }
+    }
+
     // Check for the timer command, which requires async file I/O and cannot
     // be handled by the sync command registry.
     if let Some(timer_cmd) = crate::chat::timer::extract_timer_command(
@@ -501,8 +542,14 @@ pub(super) async fn handle_message(
     // The prompt is just the current message with sender attribution.
     // Prior conversation context is carried by the Claude Code session.
     let bot_name = &ctx.bot_name;
+    let active_project_ctx = if let Some(ref ap) = ctx.gateway_active_project {
+        let name = ap.read().await.clone();
+        format!("[Active project: {name}]\n")
+    } else {
+        String::new()
+    };
     let prompt = format!(
-        "[Your name is {bot_name}. Refer to yourself as {bot_name}, not Claude.]\n\n{}",
+        "[Your name is {bot_name}. Refer to yourself as {bot_name}, not Claude.]\n{active_project_ctx}\n{}",
         format_user_prompt(&sender, &user_message)
     );
 

server/src/chat/transport/matrix/bot/run.rs

@@ -8,7 +8,7 @@ use std::path::PathBuf;
 use std::sync::Arc;
 use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
 use tokio::sync::Mutex as TokioMutex;
-use tokio::sync::{mpsc, watch};
+use tokio::sync::{RwLock, mpsc, watch};
 
 use super::context::BotContext;
 use super::format::{format_startup_announcement, markdown_to_html};
@@ -19,6 +19,7 @@ use super::verification::{on_room_verification_request, on_to_device_verificatio
 /// Connect to the Matrix homeserver, join all configured rooms, and start
 /// listening for messages. Runs the full Matrix sync loop — call from a
 /// `tokio::spawn` task so it doesn't block the main thread.
+#[allow(clippy::too_many_arguments)]
 pub async fn run_bot(
     config: super::super::config::BotConfig,
     project_root: PathBuf,
@@ -27,6 +28,8 @@ pub async fn run_bot(
     perm_rx: Arc<TokioMutex<mpsc::UnboundedReceiver<crate::http::context::PermissionForward>>>,
     agents: Arc<AgentPool>,
     shutdown_rx: watch::Receiver<Option<crate::rebuild::ShutdownReason>>,
+    gateway_active_project: Option<Arc<RwLock<String>>>,
+    gateway_projects: Vec<String>,
 ) -> Result<(), String> {
     let store_path = project_root.join(".huskies").join("matrix_store");
     let client = Client::builder()
@@ -242,6 +245,8 @@ pub async fn run_bot(
         htop_sessions: Arc::new(TokioMutex::new(HashMap::new())),
         transport: Arc::clone(&transport),
         timer_store,
+        gateway_active_project,
+        gateway_projects,
     };
 
     slog!(

server/src/chat/transport/matrix/mod.rs

@@ -37,7 +37,7 @@ use crate::io::watcher::WatcherEvent;
 use crate::rebuild::ShutdownReason;
 use std::path::Path;
 use std::sync::Arc;
-use tokio::sync::{Mutex as TokioMutex, broadcast, mpsc, watch};
+use tokio::sync::{Mutex as TokioMutex, RwLock, broadcast, mpsc, watch};
 
 /// Attempt to start the Matrix bot.
 ///
@@ -64,6 +64,8 @@ pub fn spawn_bot(
     perm_rx: Arc<TokioMutex<mpsc::UnboundedReceiver<PermissionForward>>>,
     agents: Arc<AgentPool>,
     shutdown_rx: watch::Receiver<Option<ShutdownReason>>,
+    gateway_active_project: Option<Arc<RwLock<String>>>,
+    gateway_projects: Vec<String>,
 ) {
     let config = match BotConfig::load(project_root) {
         Some(c) => c,
@@ -100,6 +102,8 @@ pub fn spawn_bot(
             perm_rx,
             agents,
             shutdown_rx,
+            gateway_active_project,
+            gateway_projects,
         )
         .await
         {