feat: graceful shutdown on Ctrl-C with MCP cleanup

crates/zeph-core/src/agent/mod.rs

@@ -500,6 +500,17 @@ impl<P: LlmProvider + Clone + 'static, C: Channel, T: ToolExecutor> Agent<P, C,
         count
     }
 
+    pub async fn shutdown(&mut self) {
+        self.channel.send("Shutting down...").await.ok();
+
+        #[cfg(feature = "mcp")]
+        if let Some(ref manager) = self.mcp.manager {
+            manager.shutdown_all_shared().await;
+        }
+
+        tracing::info!("agent shutdown complete");
+    }
+
     /// Run the chat loop, receiving messages via the channel until EOF or shutdown.
     ///
     /// # Errors

crates/zeph-core/src/agent/streaming.rs

@@ -339,7 +339,17 @@ impl<P: LlmProvider + Clone + 'static, C: Channel, T: ToolExecutor> Agent<P, C,
         let mut stream = self.provider.chat_stream(&self.messages).await?;
         let mut response = String::with_capacity(2048);
 
-        while let Some(chunk_result) = stream.next().await {
+        loop {
+            let chunk_result = tokio::select! {
+                item = stream.next() => match item {
+                    Some(r) => r,
+                    None => break,
+                },
+                () = super::shutdown_signal(&mut self.shutdown) => {
+                    tracing::info!("streaming interrupted by shutdown");
+                    break;
+                }
+            };
             let chunk: String = chunk_result?;
             response.push_str(&chunk);
             let display = self.maybe_redact(&chunk);
@@ -382,6 +392,11 @@ impl<P: LlmProvider + Clone + 'static, C: Channel, T: ToolExecutor> Agent<P, C,
         );
 
         for iteration in 0..self.max_tool_iterations {
+            if *self.shutdown.borrow() {
+                tracing::info!("native tool loop interrupted by shutdown");
+                break;
+            }
+
             self.channel.send_typing().await?;
 
             if let Some(ref budget) = self.context_state.budget {

crates/zeph-mcp/src/manager.rs

@@ -187,13 +187,23 @@ impl McpManager {
         ids
     }
 
-    /// Graceful shutdown of all connections.
+    /// Graceful shutdown of all connections (takes ownership).
     pub async fn shutdown_all(self) {
+        self.shutdown_all_shared().await;
+    }
+
+    /// Graceful shutdown of all connections via shared reference.
+    pub async fn shutdown_all_shared(&self) {
         let mut clients = self.clients.write().await;
         let drained: Vec<(String, McpClient)> = clients.drain().collect();
         for (id, client) in drained {
             tracing::info!(server_id = id, "shutting down MCP client");
-            client.shutdown().await;
+            if tokio::time::timeout(Duration::from_secs(5), client.shutdown())
+                .await
+                .is_err()
+            {
+                tracing::warn!(server_id = id, "MCP client shutdown timed out");
+            }
         }
     }
 }

src/main.rs

@@ -565,9 +565,11 @@ async fn main() -> anyhow::Result<()> {
 
         tokio::select! {
             result = tui_task => {
+                agent.shutdown().await;
                 return result?;
             }
             result = agent_future => {
+                agent.shutdown().await;
                 return result;
             }
         }
@@ -576,7 +578,9 @@ async fn main() -> anyhow::Result<()> {
     warmup_provider(&warmup_provider_clone).await;
     tokio::spawn(forward_status_to_stderr(status_rx));
     // Box::pin avoids clippy::large_futures on non-TUI path
-    Box::pin(agent.run()).await
+    let result = Box::pin(agent.run()).await;
+    agent.shutdown().await;
+    result
 }
 
 async fn forward_status_to_stderr(mut rx: tokio::sync::mpsc::UnboundedReceiver<String>) {