Close enough.

Fixed --harder mode issues:
- Remapping now only applies to normal mode, not insert mode
- Updated error messages to be accurate

Files changed:
src/nvim/brutal.c: +42/-28 (clarified quit blocking logic)
src/nvim/ex_docmd.c: +4/-4 (updated error messages)
src/nvim/getchar.c: +40/-9 (added mode check for remapping)
src/nvim/normal.c: +121/-7 (context changes)
src/nvim/os/input.c: +7/+0 (context changes)

Author: mcollard0

src/nvim/brutal.c

@@ -12,6 +12,7 @@
 
 #include "nvim/ascii_defs.h"
 #include "nvim/brutal.h"
+#include "nvim/globals.h"
 #include "nvim/keycodes.h"
 #include "nvim/message.h"
 #include "nvim/os/time.h"
@@ -117,6 +118,16 @@ void brutal_init( void )
   if ( brutal_mode == BRUTAL_HARDEST ) {
     brutal_init_keymap_hardest();
   }
+  
+  // EASY mode: Enable shift-arrow text selection and clipboard operations
+  if ( brutal_mode == BRUTAL_EASY ) {
+    // Set keymodel to include "startsel" for shift-selection
+    // This enables Shift+Arrow to start selection
+    do_cmdline_cmd( "set keymodel=startsel,stopsel" );
+    
+    // Set selectmode to "key" so Shift+Arrow enters select mode
+    do_cmdline_cmd( "set selectmode=key" );
+  }
 }
 
 /// Display brutal mode startup banner
@@ -220,38 +231,22 @@ bool brutal_should_block_key( int c )
   return false;
 }
 
-/// Apply Windows-style key mappings for EASY mode
+/// Apply Windows-style key mappings for default mode (always on)
+/// Handles Shift+Arrow for visual selection, Ctrl+C/V/X for clipboard
 /// @param c The character to remap
-/// @return The remapped character (or original if no mapping)
+/// @return The remapped character (or K_IGNORE if handled internally)
 int brutal_apply_easy_mode_mappings( int c )
 {
-  if ( brutal_mode != BRUTAL_EASY ) {
-    return c;
+  // Map Ctrl+Z to undo (always available, not just EASY mode)
+  if ( c == Ctrl_Z ) {
+    return 'u';
   }
-
-  // Windows-style shortcuts for EASY mode
-  // Ctrl+X = Cut (visual mode: delete to clipboard)
-  // Ctrl+C = Copy (visual mode: yank to clipboard)  
-  // Ctrl+V = Paste (insert/normal: paste from clipboard)
-  // Ctrl+Z = Undo
-  // Note: These mappings work by returning different keycodes
-  // The actual clipboard operations are handled by Neovim's existing
-  // visual mode and paste mechanisms
 
-  switch ( c ) {
-    case Ctrl_Z:
-      // Map Ctrl+Z to 'u' (undo) in normal mode
-      return 'u';
-    
-    // Ctrl+X, Ctrl+C, Ctrl+V are handled differently:
-    // They should trigger clipboard operations, but we keep them
-    // as-is to let Neovim's own handling work, or we can map them
-    // For now, let normal Neovim handle Ctrl+C/V
-    // Ctrl+X in normal mode can be mapped to cut line
-    
-    default:
-      return c;
-  }
+  // Shift+Arrow keys are handled in normal.c/visual mode code
+  // Ctrl+C/V/X are handled in normal.c/visual mode code
+  // This function is for simple character remapping only
+  
+  return c;
 }
 
 /// Apply key remapping for HARDEST mode
@@ -265,17 +260,34 @@ int brutal_remap_key( int c )
   return c;
 }
 
+/// Check if Windows-style keybindings should be active (EASY mode only)
+/// @return true if EASY mode is active
+bool brutal_windows_keys_active( void )
+{
+  return brutal_mode == BRUTAL_EASY;
+}
+
 /// Check if quit command should be blocked (HARDER and HARDEST modes)
 /// @param force true if using :quit! or :q!
 /// @return true if quit should be blocked
 bool brutal_should_block_quit( bool force )
 {
-  // EASY mode: allow force quit
+  // Never block quit in headless or embedded modes (build system, automation, etc.)
+  if ( headless_mode || embedded_mode ) {
+    return false;
+  }
+  
+  // Default mode (BRUTAL_NONE) and EASY/HARD: never block
+  if ( brutal_mode == BRUTAL_NONE || brutal_mode == BRUTAL_EASY || brutal_mode == BRUTAL_HARD ) {
+    return false;
+  }
+  
+  // EASY mode with force quit: allow
   if ( brutal_mode == BRUTAL_EASY && force ) {
     return false;
   }
 
-  // HARDER/HARDEST: always block
+  // HARDER/HARDEST: block ALL quit commands including forced quit
   return ( brutal_mode == BRUTAL_HARDER || brutal_mode == BRUTAL_HARDEST );
 }
 

src/nvim/ex_docmd.c

@@ -4771,9 +4771,9 @@ bool before_quit_autocmds(win_T *wp, bool quit_all, bool forceit)
 /// ":{nr}quit": quit window {nr}
 static void ex_quit(exarg_T *eap)
 {
-  // Brutal mode: block quit in HARDER and HARDEST modes (allow :q! in EASY)
+  // Brutal mode: block quit in HARDER and HARDEST modes
   if ( brutal_should_block_quit( eap->forceit ) ) {
-    emsg( "Quit commands are disabled in this brutal mode. Try :q! or :quit!" );
+    emsg( "Quit commands are disabled in this brutal mode." );
     return;
   }
 
@@ -4875,9 +4875,9 @@ int before_quit_all(exarg_T *eap)
 /// ":qall": try to quit all windows
 static void ex_quitall(exarg_T *eap)
 {
-  // Brutal mode: block quit in HARDER and HARDEST modes (allow :qa! in EASY)
+  // Brutal mode: block quit in HARDER and HARDEST modes
   if ( brutal_should_block_quit( eap->forceit ) ) {
-    emsg( "Quit commands are disabled in this brutal mode. Try :qa! or :qall!" );
+    emsg( "Quit commands are disabled in this brutal mode." );
     return;
   }
 

src/nvim/getchar.c

@@ -1773,16 +1773,44 @@ int vgetc(void)
 
       case K_KUP:
       case K_XUP:
-        c = K_UP; break;
+        c = K_UP;
+        // fall through
+      case K_UP:
+        if (mod_mask == MOD_MASK_SHIFT) {
+          c = K_S_UP;
+          mod_mask = 0;
+        }
+        break;
       case K_KDOWN:
       case K_XDOWN:
-        c = K_DOWN; break;
+        c = K_DOWN;
+        // fall through
+      case K_DOWN:
+        if (mod_mask == MOD_MASK_SHIFT) {
+          c = K_S_DOWN;
+          mod_mask = 0;
+        }
+        break;
       case K_KLEFT:
       case K_XLEFT:
-        c = K_LEFT; break;
+        c = K_LEFT;
+        // fall through
+      case K_LEFT:
+        if (mod_mask == MOD_MASK_SHIFT) {
+          c = K_S_LEFT;
+          mod_mask = 0;
+        }
+        break;
       case K_KRIGHT:
       case K_XRIGHT:
-        c = K_RIGHT; break;
+        c = K_RIGHT;
+        // fall through
+      case K_RIGHT:
+        if (mod_mask == MOD_MASK_SHIFT) {
+          c = K_S_RIGHT;
+          mod_mask = 0;
+        }
+        break;
       }
 
       break;
@@ -1792,11 +1820,14 @@ int vgetc(void)
   }
 
   // Brutal mode key filtering and remapping
-  if ( brutal_should_block_key( c ) ) {
-    c = K_IGNORE;  // Block cursor keys in HARD/HARDER/HARDEST modes
-  } else {
-    c = brutal_remap_key( c );  // Apply HARDEST mode randomization
-    c = brutal_apply_easy_mode_mappings( c );  // Apply EASY mode Windows-style mappings
+  // Only apply blocking and remapping in NORMAL mode to prevent interference with insert mode
+  if ( ( State & MODE_NORMAL ) || ( State & MODE_VISUAL ) || ( State & MODE_OP_PENDING ) ) {
+    if ( brutal_should_block_key( c ) ) {
+      c = K_IGNORE;  // Block cursor keys in HARD/HARDER/HARDEST modes
+    } else {
+      c = brutal_remap_key( c );  // Apply HARDEST mode randomization
+      c = brutal_apply_easy_mode_mappings( c );  // Apply EASY mode Windows-style mappings
+    }
   }
 
   // EASY mode: Track ESC presses (unused for now, kept for compatibility)

src/nvim/normal.c

@@ -178,7 +178,7 @@ static const struct nv_cmd {
   { Ctrl_G,    nv_ctrlg,       0,                      0 },
   { Ctrl_H,    nv_ctrlh,       0,                      0 },
   { Ctrl_I,    nv_pcmark,      0,                      0 },
-  { NL,        nv_down,        0,                      false },
+  { NL,        nv_win_visual_enter, 0,                 false },
   { Ctrl_K,    nv_error,       0,                      0 },
   { Ctrl_L,    nv_clear,       0,                      0 },
   { CAR,       nv_down,        0,                      true },
@@ -190,11 +190,11 @@ static const struct nv_cmd {
   { Ctrl_S,    nv_ignore,      0,                      0 },
   { Ctrl_T,    nv_tagpop,      NV_NCW,                 0 },
   { Ctrl_U,    nv_halfpage,    0,                      0 },
-  { Ctrl_V,    nv_visual,      0,                      false },
+  { Ctrl_V,    nv_win_paste,   0,                      false },
   { 'V',       nv_visual,      0,                      false },
   { 'v',       nv_visual,      0,                      false },
   { Ctrl_W,    nv_window,      0,                      0 },
-  { Ctrl_X,    nv_addsub,      0,                      0 },
+  { Ctrl_X,    nv_win_cut,     0,                      0 },
   { Ctrl_Y,    nv_scroll_line, 0,                      false },
   { Ctrl_Z,    nv_suspend,     0,                      0 },
   { ESC,       nv_esc,         0,                      false },
@@ -326,14 +326,14 @@ static const struct nv_cmd {
   { K_KINS,    nv_edit,        0,                      0 },
   { K_BS,      nv_ctrlh,       0,                      0 },
   { K_UP,      nv_up,          NV_SSS|NV_STS,          false },
-  { K_S_UP,    nv_page,        NV_SS,                  BACKWARD },
+  { K_S_UP,    nv_win_shift_arrow, NV_SS,              BACKWARD },
   { K_DOWN,    nv_down,        NV_SSS|NV_STS,          false },
-  { K_S_DOWN,  nv_page,        NV_SS,                  FORWARD },
+  { K_S_DOWN,  nv_win_shift_arrow, NV_SS,              FORWARD },
   { K_LEFT,    nv_left,        NV_SSS|NV_STS|NV_RL,    0 },
-  { K_S_LEFT,  nv_bck_word,    NV_SS|NV_RL,            0 },
+  { K_S_LEFT,  nv_win_shift_arrow, NV_SS|NV_RL,        0 },
   { K_C_LEFT,  nv_bck_word,    NV_SSS|NV_RL|NV_STS,    1 },
   { K_RIGHT,   nv_right,       NV_SSS|NV_STS|NV_RL,    0 },
-  { K_S_RIGHT, nv_wordcmd,     NV_SS|NV_RL,            false },
+  { K_S_RIGHT, nv_win_shift_arrow, NV_SS|NV_RL,        false },
   { K_C_RIGHT, nv_wordcmd,     NV_SSS|NV_RL|NV_STS,    true },
   { K_PAGEUP,  nv_page,        NV_SSS|NV_STS,          BACKWARD },
   { K_KPAGEUP, nv_page,        NV_SSS|NV_STS,          BACKWARD },
@@ -6152,6 +6152,24 @@ static void nv_esc(cmdarg_T *cap)
   // Brutal mode: Removed ESC detection (was unreliable)
 
   if (cap->arg) {               // true for CTRL-C
+    // EASY mode: Ctrl+C in visual mode copies to clipboard
+    if (VIsual_active && brutal_mode == BRUTAL_EASY) {
+      // Set up yank operator - use unnamed register (0 means use default)
+      // This ensures yank works even without clipboard provider
+      cap->oap->regname = 0;  // Use unnamed/default register
+      cap->oap->op_type = OP_YANK;
+      cap->cmdchar = 'y';  // Simulate 'y' command for do_pending_operator
+      
+      // Call do_pending_operator to execute the yank on the visual selection
+      do_pending_operator(cap, curwin->w_curswant, false);
+      
+      // Ensure clean state after operation
+      clearop(cap->oap);
+      // Clear got_int which may have been set by Ctrl+C signal
+      got_int = false;
+      return;
+    }
+    
     if (restart_edit == 0 && cmdwin_type == 0 && !VIsual_active && no_reason) {
       if (anyBufIsChanged()) {
         msg(_("Type  :qa!  and press <Enter> to abandon all changes"
@@ -6666,6 +6684,102 @@ static void nv_event(cmdarg_T *cap)
   }
 }
 
+/// Windows-style Ctrl+X: Cut to clipboard (EASY mode only)
+static void nv_win_cut(cmdarg_T *cap)
+{
+  if (brutal_mode != BRUTAL_EASY) {
+    // Not in EASY mode, use default Ctrl+X behavior (number decrement)
+    nv_addsub(cap);
+    return;
+  }
+  
+  if (VIsual_active) {
+    // Visual mode: cut selection to clipboard
+    cap->oap->regname = '+';
+    cap->cmdchar = 'd';
+    nv_operator(cap);
+  } else {
+    // Normal mode: cut entire line to clipboard
+    cap->oap->regname = '+';
+    cap->cmdchar = 'd';
+    cap->cmdchar = 'd';  // dd
+    nv_operator(cap);
+  }
+}
+
+/// Windows-style Ctrl+V: Paste from clipboard (EASY mode only) 
+static void nv_win_paste(cmdarg_T *cap)
+{
+  if (brutal_mode != BRUTAL_EASY) {
+    // Not in EASY mode, use default Ctrl+V behavior (visual block)
+    nv_visual(cap);
+    return;
+  }
+  
+  // Paste from clipboard register '+'
+  cap->oap->regname = '+';
+  cap->cmdchar = 'p';
+  nv_put(cap);
+}
+
+/// Enter in visual mode: Copy and exit (EASY mode only)
+static void nv_win_visual_enter(cmdarg_T *cap)
+{
+  if (brutal_mode != BRUTAL_EASY || !VIsual_active) {
+    // Not in EASY mode or not in visual - default Enter behavior
+    nv_down(cap);
+    return;
+  }
+  
+  // Copy to clipboard and exit visual mode
+  cap->oap->regname = '+';
+  cap->oap->op_type = OP_YANK;
+  op_yank(cap->oap, false);
+  end_visual_mode();
+  check_cursor_col(curwin);
+  curwin->w_set_curswant = true;
+  redraw_curbuf_later(UPD_INVERTED);
+  clearop(cap->oap);
+}
+
+/// Shift+Arrow: Start/extend visual selection (EASY mode only)
+static void nv_win_shift_arrow(cmdarg_T *cap)
+{
+  if (brutal_mode != BRUTAL_EASY) {
+    // Not in EASY mode - use default behavior
+    if (cap->cmdchar == K_S_UP) {
+      nv_page(cap);
+    } else if (cap->cmdchar == K_S_DOWN) {
+      nv_page(cap);
+    } else if (cap->cmdchar == K_S_LEFT) {
+      nv_bck_word(cap);
+    } else if (cap->cmdchar == K_S_RIGHT) {
+      nv_wordcmd(cap);
+    }
+    return;
+  }
+  
+  // EASY mode: Start visual selection if not already active
+  // Use Visual mode (not Select mode) for Windows-style selection
+  if (!VIsual_active) {
+    VIsual_select = false;  // Ensure we're in Visual, not Select mode
+    n_start_visual_mode('v');
+  }
+  
+  // Move cursor based on arrow key - visual mode extends automatically
+  if (cap->cmdchar == K_S_UP) {
+    cap->arg = false;  // nv_up expects this
+    nv_up(cap);
+  } else if (cap->cmdchar == K_S_DOWN) {
+    cap->arg = false;
+    nv_down(cap);
+  } else if (cap->cmdchar == K_S_LEFT) {
+    nv_left(cap);
+  } else if (cap->cmdchar == K_S_RIGHT) {
+    nv_right(cap);
+  }
+}
+
 void normal_cmd(oparg_T *oap, bool toplevel)
 {
   NormalState s;

src/nvim/os/input.c

@@ -9,6 +9,7 @@
 #include "nvim/api/private/defs.h"
 #include "nvim/ascii_defs.h"
 #include "nvim/autocmd.h"
+#include "nvim/brutal.h"
 #include "nvim/autocmd_defs.h"
 #include "nvim/buffer_defs.h"
 #include "nvim/event/loop.h"
@@ -542,6 +543,12 @@ static void process_ctrl_c(void)
     return;
   }
 
+  // In EASY mode with visual selection active, Ctrl+C is used for copy,
+  // so don't treat it as an interrupt signal.
+  if ( brutal_windows_keys_active() && VIsual_active ) {
+    return;
+  }
+
   size_t available = input_available();
   ssize_t i;
   for (i = (ssize_t)available - 1; i >= 0; i--) {  // Reverse-search input for Ctrl_C.