fix(resurrectable): fix delete and sort by age

- Check if session is resurrectable BEFORE optimistic removal
  (was removing from list then checking, so delete always failed)
- Sort resurrectable sessions by duration ascending (most recent first)
- Remove unused SessionAction::Kill variant

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: dbachelder

.gitignore

@@ -1,2 +1,3 @@
 /target
 /ref
+deploy.sh

deploy.sh

@@ -19,6 +19,7 @@ fi
 
 echo "Deploying to $REMOTE"
 scp "$WASM" "$REMOTE"
+cp -f "$WASM" ~/.config/zellij/plugins/
 
 echo "Done. Reload plugin in zellij with Alt+R or:"
 echo "  zellij action start-or-reload-plugin file:~/.config/zellij/plugins/zsm.wasm"

src/session/manager.rs

@@ -130,19 +130,6 @@ impl SessionManager {
             SessionAction::Switch(name) => {
                 switch_session(Some(&name));
             }
-            SessionAction::Kill(name) => {
-                if self
-                    .resurrectable_sessions
-                    .iter()
-                    .any(|(session_name, _)| session_name == &name)
-                {
-                    // If the session is resurrectable, we should delete it
-                    delete_dead_session(&name);
-                } else {
-                    // Otherwise, we need to kill the session
-                    kill_sessions(&[&name]);
-                }
-            }
         }
     }
 
@@ -197,13 +184,24 @@ impl SessionManager {
     /// Uses optimistic update - removes from local state immediately before sending kill command
     pub fn confirm_deletion(&mut self) {
         if let Some(session_name) = self.pending_deletion.take() {
+            // Check if it's a resurrectable session BEFORE the optimistic removal
+            // (removal clears the list, so we must check first)
+            let is_resurrectable = self
+                .resurrectable_sessions
+                .iter()
+                .any(|(name, _)| name == &session_name);
+
             // Optimistic update: Remove session from local state immediately
             // This provides instant UI feedback rather than waiting for MISSING_THRESHOLD updates
             self.remove_session_from_local_state(&session_name);
 
             // Now execute the actual kill/delete action
             // If this fails, the session will reappear on the next SessionUpdate event
-            self.execute_action(SessionAction::Kill(session_name));
+            if is_resurrectable {
+                delete_dead_session(&session_name);
+            } else {
+                kill_sessions(&[&session_name]);
+            }
         }
     }
 

src/session/types.rs

@@ -40,6 +40,4 @@ impl SessionItem {
 pub enum SessionAction {
     /// Switch to an existing session
     Switch(String),
-    /// Kill an existing session
-    Kill(String),
 }

src/state.rs

@@ -156,22 +156,23 @@ impl PluginState {
 
     /// Combine sessions and zoxide directories for display
     fn combined_items(&self) -> Vec<SessionItem> {
-        let mut sessions: Vec<SessionItem> = Vec::new();
+        let mut existing_sessions: Vec<SessionItem> = Vec::new();
+        let mut resurrectable_sessions: Vec<SessionItem> = Vec::new();
         let mut directories: Vec<SessionItem> = Vec::new();
         let mut added_session_names = HashSet::new();
 
         // First, collect existing sessions that match zoxide directories (including incremented ones)
         for session in self.session_manager.sessions() {
             if let Some(zoxide_dir) = self.find_matching_zoxide_dir(&session.name) {
-                sessions.push(SessionItem::ExistingSession {
+                existing_sessions.push(SessionItem::ExistingSession {
                     name: session.name.clone(),
                     directory: zoxide_dir.directory.clone(),
                     is_current: session.is_current_session,
                 });
                 added_session_names.insert(session.name.clone());
             } else if self.config.show_all_sessions {
                 // Session didn't match any zoxide dir, but show_all_sessions is enabled
-                sessions.push(SessionItem::ExistingSession {
+                existing_sessions.push(SessionItem::ExistingSession {
                     name: session.name.clone(),
                     directory: String::new(),
                     is_current: session.is_current_session,
@@ -190,7 +191,7 @@ impl PluginState {
 
                 let matches_zoxide = self.find_matching_zoxide_dir(name).is_some();
                 if matches_zoxide || self.config.show_all_sessions {
-                    sessions.push(SessionItem::ResurrectableSession {
+                    resurrectable_sessions.push(SessionItem::ResurrectableSession {
                         name: name.clone(),
                         duration: *duration,
                     });
@@ -206,24 +207,38 @@ impl PluginState {
             });
         }
 
-        // Sort sessions based on config
+        // Sort existing sessions based on config
         match self.config.sort_order {
             SortOrder::Mru => {
                 // Sort by MRU timestamp (descending - most recent first)
-                sessions.sort_by(|a, b| {
+                existing_sessions.sort_by(|a, b| {
                     let ts_a = self.session_manager.get_mru_rank(a.name());
                     let ts_b = self.session_manager.get_mru_rank(b.name());
                     ts_b.cmp(&ts_a) // Descending order
                 });
             }
             SortOrder::Alphabetical => {
                 // Sort alphabetically by name (case-insensitive)
-                sessions.sort_by_key(|a| a.name().to_lowercase());
+                existing_sessions.sort_by_key(|a| a.name().to_lowercase());
             }
         }
 
-        // Combine: sorted sessions first, then directories (already sorted by zoxide score)
-        let mut items = sessions;
+        // Sort resurrectable sessions by age (most recently killed first = smallest duration)
+        resurrectable_sessions.sort_by(|a, b| {
+            let dur_a = match a {
+                SessionItem::ResurrectableSession { duration, .. } => *duration,
+                _ => std::time::Duration::MAX,
+            };
+            let dur_b = match b {
+                SessionItem::ResurrectableSession { duration, .. } => *duration,
+                _ => std::time::Duration::MAX,
+            };
+            dur_a.cmp(&dur_b) // Ascending order (smallest/most recent first)
+        });
+
+        // Combine: existing sessions, then resurrectable, then directories
+        let mut items = existing_sessions;
+        items.append(&mut resurrectable_sessions);
         items.append(&mut directories);
         items
     }