runtime restart discord command (admin-only)

Author: orual

crates/pattern_cli/src/discord.rs

@@ -30,6 +30,8 @@ use pattern_discord::{
     endpoints::DiscordEndpoint,
 };
 #[cfg(feature = "discord")]
+use std::os::unix::process::CommandExt;
+#[cfg(feature = "discord")]
 use std::sync::Arc;
 
 /// Set up Discord endpoint for an agent if configured
@@ -283,12 +285,15 @@ pub async fn run_discord_bot_with_group(
         let sinks =
             crate::forwarding::build_discord_group_sinks(&output, &agents_with_membership).await;
 
+        let (restart_tx, mut restart_rx) = tokio::sync::mpsc::channel(1);
+
         let bot = Arc::new(DiscordBot::new_cli_mode(
             bot_cfg,
             agents_with_membership.clone(),
             group.clone(),
             pattern_manager.clone(),
             Some(sinks),
+            restart_tx.clone(),
         ));
 
         // Connect the bot to the Discord endpoint for timing context
@@ -346,6 +351,19 @@ pub async fn run_discord_bot_with_group(
                 }
             });
 
+            tokio::spawn(async move {
+                restart_rx.recv().await;
+                tracing::info!("restart signal received");
+                let _ = crossterm::terminal::disable_raw_mode();
+
+                let exe = std::env::current_exe().unwrap();
+                let args: Vec<String> = std::env::args().collect();
+
+                let _ = std::process::Command::new(exe).args(&args[1..]).exec();
+
+                std::process::exit(0);
+            });
+
             // Run CLI chat loop in foreground
             if let Some(rl) = rl {
                 run_group_chat_loop(

crates/pattern_cli/src/forwarding.rs

@@ -3,7 +3,6 @@ use std::sync::Arc;
 
 use async_trait::async_trait;
 use chrono::Utc;
-use owo_colors::OwoColorize;
 use pattern_core::{
     Agent,
     agent::ResponseEvent,
@@ -167,19 +166,6 @@ pub async fn build_discord_group_sinks(
     build_group_sinks(output, agents, "Discord").await
 }
 
-/// Helper: build file-only sinks for CLI routes (avoid double printing)
-pub async fn build_cli_group_file_sinks() -> Vec<Arc<dyn GroupEventSink>> {
-    let mut sinks: Vec<Arc<dyn GroupEventSink>> = Vec::new();
-    if let Ok(path) = std::env::var("PATTERN_FORWARD_FILE") {
-        if !path.trim().is_empty() {
-            if let Ok(sink) = FileGroupSink::create(PathBuf::from(path)).await {
-                sinks.push(Arc::new(sink));
-            }
-        }
-    }
-    sinks
-}
-
 /// Build group sinks for CLI-initiated group chat (CLI printer + optional file)
 pub async fn build_cli_group_sinks(
     output: &Output,
@@ -196,19 +182,6 @@ pub async fn build_jetstream_group_sinks(
     build_group_sinks(output, agents, "Jetstream").await
 }
 
-/// Build agent sinks for CLI agent chat (file-only to avoid double printing)
-pub async fn build_cli_agent_file_sinks() -> Vec<Arc<dyn AgentEventSink>> {
-    let mut sinks: Vec<Arc<dyn AgentEventSink>> = Vec::new();
-    if let Ok(path) = std::env::var("PATTERN_FORWARD_FILE") {
-        if !path.trim().is_empty() {
-            if let Ok(sink) = FileAgentSink::create(PathBuf::from(path)).await {
-                sinks.push(Arc::new(sink));
-            }
-        }
-    }
-    sinks
-}
-
 /// Build agent sinks for single-agent CLI chat: CLI printer + optional file
 pub async fn build_cli_agent_sinks(output: &Output) -> Vec<Arc<dyn AgentEventSink>> {
     let mut sinks: Vec<Arc<dyn AgentEventSink>> = Vec::new();

crates/pattern_core/src/agent/impls/db_agent.rs

@@ -14,8 +14,7 @@ use crate::db::DbEntity;
 use crate::id::RelationId;
 use crate::memory::MemoryType;
 use crate::message::{
-    BatchType, ChatRole, ContentBlock, ContentPart, ImageSource, Request, Response, ToolCall,
-    ToolResponse,
+    BatchType, ContentBlock, ContentPart, ImageSource, Request, Response, ToolCall, ToolResponse,
 };
 use crate::model::ResponseOptions;
 use crate::tool::builtin::BuiltinTools;
@@ -28,7 +27,7 @@ use crate::{
         tool_rules::{ToolRule, ToolRuleEngine},
     },
     context::{
-        AgentContext, CompressionStrategy, ContextConfig, NON_USER_MESSAGE_PREFIX,
+        AgentContext, CompressionStrategy, ContextConfig,
         heartbeat::{HeartbeatSender, check_heartbeat_request},
     },
     db::{DatabaseError, ops, schema},

crates/pattern_core/src/coordination/patterns/sleeptime.rs

@@ -7,6 +7,7 @@ use std::{sync::Arc, time::Duration};
 use crate::{
     Result,
     agent::Agent,
+    context::NON_USER_MESSAGE_PREFIX,
     coordination::{
         groups::{
             AgentResponse, AgentWithMembership, GroupManager, GroupResponse, GroupResponseEvent,
@@ -168,7 +169,8 @@ impl GroupManager for SleeptimeManager {
                             let trigger_names: Vec<_> =
                                 fired_triggers.iter().map(|t| t.name.as_str()).collect();
                             let mut context = format!(
-                                "[Sleeptime Intervention] Triggers fired: {}. {}",
+                                "{}[Background Intervention] Triggers fired: {}. {}",
+                                NON_USER_MESSAGE_PREFIX,
                                 trigger_names.join(", "),
                                 Self::get_intervention_message_static(&fired_triggers)
                             );
@@ -453,7 +455,10 @@ impl SleeptimeManager {
             },
         };
 
-        format!("[Periodic Context Sync] {}{}", now, prompt)
+        format!(
+            "{}[Periodic Context Sync] {}{}",
+            NON_USER_MESSAGE_PREFIX, now, prompt
+        )
     }
 
     /// Find the agent that was least recently active

crates/pattern_core/src/model.rs

@@ -353,6 +353,9 @@ impl ModelProvider for GenAiClient {
     async fn complete(&self, options: &ResponseOptions, mut request: Request) -> Result<Response> {
         let (model_info, chat_options) = options.to_chat_options_tuple();
 
+        // Validate image URLs are accessible (to avoid anthropic's terrible error handling)
+        self.validate_image_urls(&mut request).await;
+
         // Convert URL images to base64 for Gemini models
         tracing::debug!(
             "Model ID: {}, checking if it starts with 'gemini'",
@@ -371,9 +374,6 @@ impl ModelProvider for GenAiClient {
             );
         }
 
-        // Validate image URLs are accessible (to avoid anthropic's terrible error handling)
-        self.validate_image_urls(&mut request).await;
-
         // Log the full request
         let chat_request = request.as_chat_request()?;
 

crates/pattern_discord/src/bot.rs

@@ -88,6 +88,9 @@ pub struct DiscordBot {
 
     /// Cached bot user ID (set on Ready)
     bot_user_id: Arc<Mutex<Option<u64>>>,
+
+    /// restart channel sender
+    restart_ch: tokio::sync::mpsc::Sender<()>,
 }
 
 /// Configuration for the Discord bot
@@ -223,6 +226,7 @@ impl DiscordBot {
         group: AgentGroup,
         group_manager: Arc<dyn GroupManager>,
         group_event_sinks: Option<Vec<Arc<dyn GroupEventSink>>>,
+        restart_ch: tokio::sync::mpsc::Sender<()>,
     ) -> Self {
         Self {
             cli_mode: true,
@@ -242,11 +246,15 @@ impl DiscordBot {
             recent_activity_by_channel: Arc::new(Mutex::new(HashMap::new())),
             group_event_sinks,
             bot_user_id: Arc::new(Mutex::new(None)),
+            restart_ch,
         }
     }
 
     /// Create a new Discord bot for full mode (with database)
-    pub fn new_full_mode(config: DiscordBotConfig) -> Self {
+    pub fn new_full_mode(
+        config: DiscordBotConfig,
+        restart_ch: tokio::sync::mpsc::Sender<()>,
+    ) -> Self {
         Self {
             cli_mode: false,
             agents_with_membership: None,
@@ -265,6 +273,7 @@ impl DiscordBot {
             recent_activity_by_channel: Arc::new(Mutex::new(HashMap::new())),
             group_event_sinks: None,
             bot_user_id: Arc::new(Mutex::new(None)),
+            restart_ch,
         }
     }
 }
@@ -375,8 +384,10 @@ impl EventHandler for DiscordEventHandler {
                 if !sent {
                     // Post to all configured channels
                     for cid in &channel_ids {
-                        let _ = ChannelId::new(*cid).say(&http, content.clone()).await.ok();
-                        sent = true;
+                        if !sent {
+                            let _ = ChannelId::new(*cid).say(&http, content.clone()).await.ok();
+                            sent = true;
+                        }
                     }
                 }
             }
@@ -759,14 +770,15 @@ impl EventHandler for DiscordEventHandler {
             // Get agents and group for slash command handlers
             let agents = self.bot.agents_with_membership.as_deref();
             let group = self.bot.group.as_ref();
+            let restart_ch = &self.bot.restart_ch;
 
             let result = match command.data.name.as_str() {
                 "help" => crate::slash_commands::handle_help_command(&ctx, &command, agents).await,
                 "status" => {
                     crate::slash_commands::handle_status_command(&ctx, &command, agents, group)
                         .await
                 }
-                "memory" | "archival" | "context" | "search" => {
+                "memory" | "archival" | "context" | "search" | "restart" => {
                     // Check user authorization for sensitive commands
                     if let Some(ref admin_users) = self.bot.config.admin_users {
                         let user_id_str = command.user.id.get().to_string();
@@ -806,6 +818,12 @@ impl EventHandler for DiscordEventHandler {
                             crate::slash_commands::handle_search_command(&ctx, &command, agents)
                                 .await
                         }
+                        "restart" => {
+                            crate::slash_commands::handle_restart_command(
+                                &ctx, &command, restart_ch,
+                            )
+                            .await
+                        }
                         _ => unreachable!(),
                     }
                 }

crates/pattern_discord/src/endpoints/discord.rs

@@ -39,7 +39,7 @@ impl DiscordEndpoint {
     fn dm_tagged_content(content: &str, origin: Option<&MessageOrigin>) -> String {
         if let Some(MessageOrigin::Agent { name, .. }) = origin {
             // Subtle Markdown tag so recipients know which facet is speaking
-            format!("*[{}]* {}", name, content)
+            format!("*[{}]*\n{}", name, content)
         } else {
             content.to_string()
         }
@@ -515,7 +515,12 @@ impl DiscordEndpoint {
     }
 
     /// Send a message to a specific Discord channel
-    async fn send_to_channel(&self, channel_id: ChannelId, content: String) -> Result<()> {
+    async fn send_to_channel(
+        &self,
+        channel_id: ChannelId,
+        mut content: String,
+        origin: Option<&MessageOrigin>,
+    ) -> Result<()> {
         info!(
             "send_to_channel called with content: '{}', is_reaction: {}",
             content,
@@ -599,6 +604,13 @@ impl DiscordEndpoint {
             }
         }
 
+        // If this is a DM channel, add facet tag for clarity
+        if let Ok(channel) = channel_id.to_channel(&self.http).await {
+            if matches!(channel, serenity::model::channel::Channel::Private(_)) {
+                content = Self::dm_tagged_content(&content, origin);
+            }
+        }
+
         // Fall back to sending as regular message with timeout
         match tokio::time::timeout(
             std::time::Duration::from_secs(10),
@@ -760,20 +772,20 @@ impl MessageEndpoint for DiscordEndpoint {
                                     "Failed to reply to message: {}, falling back to channel send",
                                     e
                                 );
-                                self.send_to_channel(channel, content).await?;
+                                self.send_to_channel(channel, content, origin).await?;
                             } else {
                                 info!("Replied to message {} in channel {}", msg_id, channel_id);
                                 return Ok(Some(format!("reply:{}:{}", channel_id, msg_id)));
                             }
                         } else {
                             // Can't find original message, just send to channel
-                            self.send_to_channel(channel, content).await?;
+                            self.send_to_channel(channel, content, origin).await?;
                         }
                     } else {
-                        self.send_to_channel(channel, content).await?;
+                        self.send_to_channel(channel, content, origin).await?;
                     }
                 } else {
-                    self.send_to_channel(channel, content).await?;
+                    self.send_to_channel(channel, content, origin).await?;
                 }
                 return Ok(Some(format!("channel:{}", channel_id)));
             }
@@ -797,7 +809,7 @@ impl MessageEndpoint for DiscordEndpoint {
                             }
                         }
                     }
-                    self.send_to_channel(channel_id, content).await?;
+                    self.send_to_channel(channel_id, content, origin).await?;
                     return Ok(Some(format!("channel:{}", channel_id)));
                 }
 
@@ -829,7 +841,7 @@ impl MessageEndpoint for DiscordEndpoint {
                             }
                         }
                     }
-                    self.send_to_channel(ChannelId::new(channel_id), content)
+                    self.send_to_channel(ChannelId::new(channel_id), content, origin)
                         .await?;
                     return Ok(Some(format!("channel:{}", channel_id)));
                 }
@@ -860,7 +872,7 @@ impl MessageEndpoint for DiscordEndpoint {
         {
             // Prefer channel if both are present (came from a channel message)
             if let Ok(chan_id) = channel_id.parse::<u64>() {
-                self.send_to_channel(ChannelId::new(chan_id), content)
+                self.send_to_channel(ChannelId::new(chan_id), content, origin)
                     .await?;
                 return Ok(Some(format!("channel:{}", chan_id)));
             } else if let Ok(usr_id) = user_id.parse::<u64>() {
@@ -879,7 +891,7 @@ impl MessageEndpoint for DiscordEndpoint {
 
         // Fall back to default channel if configured
         if let Some(channel) = self.default_channel {
-            self.send_to_channel(channel, content).await?;
+            self.send_to_channel(channel, content, origin).await?;
             return Ok(Some(format!("default_channel:{}", channel)));
         }