feat(ui): Add keybinds side panel + richer Users/Groups details; Shift+K toggle

- Keybindings
  - New right-side keybinds panel with grouped, aligned columns; bold titles, italic dynamic values; visible separator.
  - Removed inline header hints; header background now matches app bg.
  - Expose `Keymap::all_bindings` and `Keymap::format_key`; `format_action` made public.
  - Toggle panel with Shift+K (supports variants); restore vim `k` to MoveUp; remove Ctrl+Tab pane toggle.
  - Add help modal and update content.

- Users details
  - Show primary group name; home existence and octal perms; shell validity (in /etc/shells) and interactivity.
  - Password status via shadow (locked/no_password/expired) with last-change/expiry days.
  - Sudo membership using configurable group `UGM_SUDO_GROUP` (default wheel).
  - SSH authorized_keys count; process count; increased pane height.

- Groups details
  - System/user classification; counts: primary vs secondary members.
  - Alphabetical top-N members preview with “(+N more)”.
  - Shell distribution (interactive vs noninteractive); UID class counts.
  - Shadow status counts; orphan secondary members detection.
  - Sudo-capable flag via configurable sudo group; `/etc/group` mtime proxy.
  - Pane height and layout adjustments.

- QA/maintenance
  - Tests updated (including toggle mapping/state); clippy clean (vec init fix).
  - Minor layout/style cleanups.

Env:
- `UGM_SUDO_GROUP` selects the sudo group name (defaults to `wheel`).

Author: Firstp1ck

src/app/keymap.rs

@@ -6,10 +6,14 @@ use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
 pub enum KeyAction {
     Quit,
     OpenFilterMenu,
+    OpenHelp,
     StartSearch,
     NewUser,
+    DeleteSelection,
     SwitchTab,
     ToggleUsersFocus,
+    ToggleGroupsFocus,
+    ToggleKeybindsPane,
     EnterAction,
     MoveUp,
     MoveDown,
@@ -37,21 +41,32 @@ impl Keymap {
         bindings.insert((M::NONE, Char('f')), KeyAction::OpenFilterMenu);
         bindings.insert((M::NONE, Char('/')), KeyAction::StartSearch);
         bindings.insert((M::NONE, Char('n')), KeyAction::NewUser);
+        bindings.insert((M::NONE, Char('?')), KeyAction::OpenHelp);
+        bindings.insert((M::NONE, KeyCode::Delete), KeyAction::DeleteSelection);
         bindings.insert((M::NONE, Tab), KeyAction::SwitchTab);
         // Shift+Tab is BackTab in crossterm
         bindings.insert((M::NONE, BackTab), KeyAction::ToggleUsersFocus);
+        // Some terminals report BackTab with SHIFT modifier, and some send Tab+SHIFT
+        bindings.insert((M::SHIFT, BackTab), KeyAction::ToggleUsersFocus);
+        bindings.insert((M::SHIFT, Tab), KeyAction::ToggleUsersFocus);
+        // Ctrl+Tab no longer toggles panes in Groups
 
         bindings.insert((M::NONE, Enter), KeyAction::EnterAction);
         // Navigation
         bindings.insert((M::NONE, Up), KeyAction::MoveUp);
         bindings.insert((M::NONE, Down), KeyAction::MoveDown);
         bindings.insert((M::NONE, Left), KeyAction::MoveLeftPage);
         bindings.insert((M::NONE, Right), KeyAction::MoveRightPage);
-        // Vim keys
+        // Vim-like keys
         bindings.insert((M::NONE, Char('k')), KeyAction::MoveUp);
         bindings.insert((M::NONE, Char('j')), KeyAction::MoveDown);
         bindings.insert((M::NONE, Char('h')), KeyAction::MoveLeftPage);
         bindings.insert((M::NONE, Char('l')), KeyAction::MoveRightPage);
+        // Toggle keybindings pane (support Shift+K variants across terminals)
+        bindings.insert((M::SHIFT, Char('k')), KeyAction::ToggleKeybindsPane);
+        bindings.insert((M::SHIFT, Char('K')), KeyAction::ToggleKeybindsPane);
+        bindings.insert((M::NONE, Char('K')), KeyAction::ToggleKeybindsPane);
+
         // Page keys
         bindings.insert((M::NONE, PageUp), KeyAction::PageUp);
         bindings.insert((M::NONE, PageDown), KeyAction::PageDown);
@@ -106,8 +121,9 @@ impl Keymap {
         let mut buf = String::new();
         buf.push_str("# usrgrp-manager keybindings\n");
         buf.push_str("# Format: <Action> = <KeySpec>\n");
-        buf.push_str("# KeySpec examples: q, Ctrl+q, Enter, Esc, Tab, BackTab, Up, Down, Left, Right, PageUp, PageDown, /, n, f, j, k, h, l\n");
-        buf.push_str("# Actions: Quit, OpenFilterMenu, StartSearch, NewUser, SwitchTab, ToggleUsersFocus, EnterAction, MoveUp, MoveDown, MoveLeftPage, MoveRightPage, PageUp, PageDown, Ignore\n\n");
+        buf.push_str("# KeySpec examples: q, Ctrl+q, Enter, Esc, Tab, BackTab, Up, Down, Left, Right, PageUp, PageDown, Delete, /, n, f, j, k, h, l\n");
+        buf.push_str("# Actions: Quit, OpenFilterMenu, StartSearch, NewUser, DeleteSelection, SwitchTab, ToggleUsersFocus, ToggleGroupsFocus, ToggleKeybindsPane, EnterAction, MoveUp, MoveDown, MoveLeftPage, MoveRightPage, PageUp, PageDown, Ignore\n\n");
+        buf.push_str("# Additional: OpenHelp (mapped to '?')\n\n");
 
         // Emit a stable, readable subset of current bindings
         let dump = [
@@ -118,6 +134,7 @@ impl Keymap {
             ("n", KeyAction::NewUser),
             ("Tab", KeyAction::SwitchTab),
             ("BackTab", KeyAction::ToggleUsersFocus),
+            ("?", KeyAction::OpenHelp),
             ("Enter", KeyAction::EnterAction),
             ("Up", KeyAction::MoveUp),
             ("Down", KeyAction::MoveDown),
@@ -129,6 +146,7 @@ impl Keymap {
             ("l", KeyAction::MoveRightPage),
             ("PageUp", KeyAction::PageUp),
             ("PageDown", KeyAction::PageDown),
+            ("Delete", KeyAction::DeleteSelection),
         ];
         for (k, a) in dump {
             let _ = writeln!(&mut buf, "{} = {}", format_action(a), k);
@@ -142,6 +160,40 @@ impl Keymap {
         let code = key.code;
         self.bindings.get(&(mm, code)).copied()
     }
+
+    /// Return a snapshot of all bindings as ((modifiers, code), action) pairs.
+    pub fn all_bindings(&self) -> Vec<((KeyModifiers, KeyCode), KeyAction)> {
+        self.bindings.iter().map(|(k, v)| (*k, *v)).collect()
+    }
+
+    /// Format a key (modifiers + code) into a human-readable spec like "Ctrl+q", "BackTab".
+    pub fn format_key(mods: KeyModifiers, code: KeyCode) -> String {
+        use KeyCode::*;
+        let base = match code {
+            Enter => "Enter".to_string(),
+            Delete => "Delete".to_string(),
+            Esc => "Esc".to_string(),
+            Tab => "Tab".to_string(),
+            BackTab => "BackTab".to_string(),
+            Up => "Up".to_string(),
+            Down => "Down".to_string(),
+            Left => "Left".to_string(),
+            Right => "Right".to_string(),
+            PageUp => "PageUp".to_string(),
+            PageDown => "PageDown".to_string(),
+            Char('/') => "/".to_string(),
+            Char(c) => c.to_string(),
+            _ => format!("{:?}", code),
+        };
+        if mods.contains(KeyModifiers::CONTROL) {
+            format!("Ctrl+{}", base)
+        } else if mods.is_empty() {
+            base
+        } else {
+            // Future: format other modifiers when supported
+            base
+        }
+    }
 }
 
 impl Default for Keymap {
@@ -162,6 +214,7 @@ fn parse_key(spec: &str) -> Option<(KeyModifiers, KeyCode)> {
     // Future: Alt+ / Shift+
     let code = match rest {
         "Enter" => Enter,
+        "Delete" => Delete,
         "/" => Char('/'),
         "Esc" | "Escape" => Esc,
         "Tab" => Tab,
@@ -188,10 +241,14 @@ fn parse_action(s: &str) -> Option<KeyAction> {
     match s.trim() {
         "Quit" => Some(KeyAction::Quit),
         "OpenFilterMenu" => Some(KeyAction::OpenFilterMenu),
+        "OpenHelp" => Some(KeyAction::OpenHelp),
         "StartSearch" => Some(KeyAction::StartSearch),
         "NewUser" => Some(KeyAction::NewUser),
+        "DeleteSelection" => Some(KeyAction::DeleteSelection),
         "SwitchTab" => Some(KeyAction::SwitchTab),
         "ToggleUsersFocus" => Some(KeyAction::ToggleUsersFocus),
+        "ToggleGroupsFocus" => Some(KeyAction::ToggleGroupsFocus),
+        "ToggleKeybindsPane" => Some(KeyAction::ToggleKeybindsPane),
         "EnterAction" => Some(KeyAction::EnterAction),
         "MoveUp" => Some(KeyAction::MoveUp),
         "MoveDown" => Some(KeyAction::MoveDown),
@@ -204,14 +261,18 @@ fn parse_action(s: &str) -> Option<KeyAction> {
     }
 }
 
-fn format_action(a: KeyAction) -> &'static str {
+pub fn format_action(a: KeyAction) -> &'static str {
     match a {
         KeyAction::Quit => "Quit",
         KeyAction::OpenFilterMenu => "OpenFilterMenu",
+        KeyAction::OpenHelp => "OpenHelp",
         KeyAction::StartSearch => "StartSearch",
         KeyAction::NewUser => "NewUser",
+        KeyAction::DeleteSelection => "DeleteSelection",
         KeyAction::SwitchTab => "SwitchTab",
         KeyAction::ToggleUsersFocus => "ToggleUsersFocus",
+        KeyAction::ToggleGroupsFocus => "ToggleGroupsFocus",
+        KeyAction::ToggleKeybindsPane => "ToggleKeybindsPane",
         KeyAction::EnterAction => "EnterAction",
         KeyAction::MoveUp => "MoveUp",
         KeyAction::MoveDown => "MoveDown",

src/app/mod.rs

@@ -264,6 +264,9 @@ pub enum ModalState {
     Info {
         message: String,
     },
+    Help {
+        scroll: u16,
+    },
     SudoPrompt {
         next: PendingAction,
         password: String,
@@ -278,6 +281,11 @@ pub enum ModalState {
     },
     GroupDeleteConfirm {
         selected: usize,
+        target_gid: Option<u32>,
+    },
+    ConfirmRemoveUserFromGroup {
+        selected: usize,
+        group_name: String,
     },
     GroupModifyMenu {
         selected: usize,
@@ -339,6 +347,17 @@ pub enum GroupsFilter {
     OnlySystemGids, // gid < 1000
 }
 
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum GroupsFocus {
+    GroupsList,
+    Members,
+}
+
+#[derive(Clone, Debug)]
+pub enum ActionsContext {
+    GroupMemberRemoval { group_name: String },
+}
+
 /// Actions that require privileged changes, executed via `sys::SystemAdapter`.
 #[derive(Clone, Debug)]
 pub enum PendingAction {
@@ -418,6 +437,7 @@ pub struct AppState {
     pub active_tab: ActiveTab,
     pub selected_user_index: usize,
     pub selected_group_index: usize,
+    pub selected_group_member_index: usize,
     pub rows_per_page: usize,
     pub _table_state: TableState,
     pub input_mode: InputMode,
@@ -426,10 +446,13 @@ pub struct AppState {
     pub keymap: keymap::Keymap,
     pub modal: Option<ModalState>,
     pub users_focus: UsersFocus,
+    pub groups_focus: GroupsFocus,
     pub sudo_password: Option<String>,
     pub users_filter: Option<UsersFilter>,
     pub groups_filter: Option<GroupsFilter>,
     pub users_filter_chips: UsersFilterChips,
+    pub actions_context: Option<ActionsContext>,
+    pub show_keybinds: bool,
 }
 
 impl AppState {
@@ -449,6 +472,7 @@ impl AppState {
             active_tab: ActiveTab::Users,
             selected_user_index: 0,
             selected_group_index: 0,
+            selected_group_member_index: 0,
             rows_per_page: 10,
             _table_state: TableState::default(),
             input_mode: InputMode::Normal,
@@ -463,10 +487,13 @@ impl AppState {
             ),
             modal: None,
             users_focus: UsersFocus::UsersList,
+            groups_focus: GroupsFocus::GroupsList,
             sudo_password: None,
             users_filter: None,
             groups_filter: None,
             users_filter_chips: UsersFilterChips::default(),
+            actions_context: None,
+            show_keybinds: true,
         };
 
         // Load and apply filter configuration from filter.conf (creates default if missing/empty)
@@ -538,3 +565,8 @@ impl Default for AppState {
 
 /// Re-export the application event loop entry function.
 pub use update::run_app as run;
+
+/// Resolve the sudo group name from environment, defaulting to "wheel".
+pub fn sudo_group_name() -> String {
+    std::env::var("UGM_SUDO_GROUP").unwrap_or_else(|_| "wheel".to_string())
+}