huskies: merge 1163 story Replace perm_rx lock-as-presence-signal with a permission router

server/src/chat/transport/slack/commands/llm.rs

@@ -82,14 +82,14 @@ pub(super) async fn handle_llm_message(
     );
     tokio::pin!(chat_fut);
 
-    // Lock the permission receiver for the duration of this chat session.
-    let mut perm_rx_guard = ctx.services.perm_rx.lock().await;
+    // Register as a permission responder for the duration of this chat turn.
+    let (_perm_guard, mut perm_rx) = ctx.services.permission_registry.register();
 
     let result = loop {
         tokio::select! {
             r = &mut chat_fut => break r,
 
-            Some(perm_fwd) = perm_rx_guard.recv() => {
+            Some(perm_fwd) = perm_rx.recv() => {
                 let prompt_msg = format!(
                     "*Permission Request*\n\nTool: `{}`\n```json\n{}\n```\n\nReply *yes* to approve or *no* to deny.",
                     perm_fwd.tool_name,
@@ -100,20 +100,22 @@ pub(super) async fn handle_llm_message(
                 let _ = ctx.transport.send_message(channel, &formatted, "").await;
 
                 // Store the response sender so the incoming message handler
-                // can resolve it when the user replies yes/no.
+                // can resolve it when the user replies yes/no. Keyed by
+                // request_id (not just channel) so a second concurrent
+                // request doesn't drop the first's sender.
                 ctx.services.pending_perm_replies
-                    .lock()
-                    .await
-                    .insert(channel.to_string(), perm_fwd.response_tx);
+                    .insert(channel.to_string(), perm_fwd.request_id.clone(), perm_fwd.response_tx)
+                    .await;
 
                 // Spawn a timeout task: auto-deny if the user does not respond.
                 let pending = Arc::clone(&ctx.services.pending_perm_replies);
                 let timeout_channel = channel.to_string();
+                let timeout_request_id = perm_fwd.request_id.clone();
                 let timeout_transport = Arc::clone(&ctx.transport);
                 let timeout_secs = ctx.services.permission_timeout_secs;
                 tokio::spawn(async move {
                     tokio::time::sleep(std::time::Duration::from_secs(timeout_secs)).await;
-                    if let Some(tx) = pending.lock().await.remove(&timeout_channel) {
+                    if let Some(tx) = pending.remove_by_request_id(&timeout_channel, &timeout_request_id).await {
                         let _ = tx.send(PermissionDecision::Deny);
                         let msg = "Permission request timed out — denied (fail-closed).";
                         let _ = timeout_transport.send_message(&timeout_channel, msg, "").await;
@@ -122,7 +124,6 @@ pub(super) async fn handle_llm_message(
             }
         }
     };
-    drop(perm_rx_guard);
 
     // Flush remaining text.
     let remaining = buffer.lock().unwrap().trim().to_string();

server/src/chat/transport/slack/commands/mod.rs

@@ -92,8 +92,12 @@ pub(super) async fn handle_incoming_message(
     // If there is a pending permission prompt for this channel, interpret the
     // message as a yes/no response instead of starting a new command/LLM flow.
     {
-        let mut pending = ctx.services.pending_perm_replies.lock().await;
-        if let Some(tx) = pending.remove(channel) {
+        if let Some(tx) = ctx
+            .services
+            .pending_perm_replies
+            .resolve_oldest(channel)
+            .await
+        {
             let decision = if is_permission_approval(message) {
                 PermissionDecision::Approve
             } else {