feat(rust-cli): wire SIGINT trap handler into REPL loops

The `trap 'handler' INT` mechanism was registering handlers in the
TrapTable but never firing them. Now:

- Both REPL variants (basic and enhanced/reedline) check for pending
  SIGINT after each command cycle and execute the registered INT trap
  handler if one exists.
- The enhanced REPL also fires INT traps on Ctrl-C (reedline returns
  Signal::CtrlC directly, bypassing the ctrlc crate's async flag).
- A new public helper `run_pending_traps(state)` in executable.rs
  encapsulates the check-and-fire logic. It checks the SIGINT flag,
  clears it, looks up the INT trap handler, parses and executes it.
  Returns true if the handler produced an Exit result.
- EXIT trap was already firing at shell exit (main.rs). No change.

Tests: 7 new tests covering trap registration, trap reset, INT trap
firing via run_pending_traps (with and without handler), no-signal
noop, and EXIT trap manual firing.

Test results: 736 passing, 0 failing, 14 ignored (up from 729).

https://claude.ai/code/session_01EMHrh5Jq32pb98KXoSKLA4

Author: claude

impl/rust-cli/src/enhanced_repl.rs

@@ -19,7 +19,7 @@ use reedline::{
 use std::borrow::Cow;
 use std::path::PathBuf;
 
-use crate::executable::{ExecutableCommand, ExecutionResult};
+use crate::executable::{self, ExecutableCommand, ExecutionResult};
 use crate::highlighter::VshHighlighter;
 use crate::parser;
 use crate::signals;
@@ -312,6 +312,17 @@ pub fn run(state: &mut ShellState) -> Result<()> {
                     accumulated_input.clear();
                     // Cancel multi-line input
                 }
+                // Fire INT trap if registered (e.g. trap 'echo caught' INT).
+                // Reedline handles Ctrl-C itself (returns Signal::CtrlC) so
+                // we fire the trap synchronously here rather than relying on
+                // the SIGINT flag.
+                if let Some(handler) = state.traps.get(crate::posix_builtins::TrapSignal::Int).map(|s| s.to_string()) {
+                    if let Ok(cmd) = parser::parse_command(&handler) {
+                        if let Ok(ExecutionResult::Exit) = cmd.execute(state) {
+                            break;
+                        }
+                    }
+                }
                 continue;
             }
             Err(err) => {
@@ -342,6 +353,10 @@ fn execute_segments(state: &mut ShellState, input: &str) -> Result<bool> {
             }
         }
     }
+    // Fire any pending signal traps (e.g. trap 'handler' INT).
+    if executable::run_pending_traps(state) {
+        return Ok(true);
+    }
     Ok(false)
 }
 

impl/rust-cli/src/executable.rs

@@ -1575,3 +1575,32 @@ fn glob_match_inner(pattern: &[char], text: &[char], pi: usize, ti: usize) -> bo
         }
     }
 }
+
+/// Check for pending signal traps and fire them.
+///
+/// Call this from the REPL loop after each command completes. If SIGINT
+/// was received and the user has set `trap '...' INT`, the trap handler
+/// is executed. If no trap is set, the interrupt is silently cleared
+/// (the current behaviour — just cancel the current line).
+///
+/// Returns `true` if an EXIT result was produced by the trap handler
+/// (i.e. the shell should quit).
+pub fn run_pending_traps(state: &mut ShellState) -> bool {
+    use crate::posix_builtins::TrapSignal;
+
+    if crate::signals::is_interrupt_requested() {
+        crate::signals::clear_interrupt();
+
+        if let Some(handler) = state.traps.get(TrapSignal::Int).map(|s| s.to_string()) {
+            if let Ok(cmd) = crate::parser::parse_command(&handler) {
+                if let Ok(result) = cmd.execute(state) {
+                    if matches!(result, ExecutionResult::Exit) {
+                        return true;
+                    }
+                }
+            }
+        }
+    }
+
+    false
+}

impl/rust-cli/src/repl.rs

@@ -10,7 +10,7 @@ use anyhow::Result;
 use colored::Colorize;
 use std::io::{self, BufRead, Write};
 
-use crate::executable::{ExecutableCommand, ExecutionResult};
+use crate::executable::{self, ExecutableCommand, ExecutionResult};
 use crate::parser;
 use crate::signals;
 use crate::state::ShellState;
@@ -91,6 +91,12 @@ pub fn run(state: &mut ShellState) -> Result<()> {
                 }
             }
         }
+
+        // Fire any pending signal traps (e.g. trap 'handler' INT).
+        if executable::run_pending_traps(state) {
+            break;
+        }
+
         if should_break {
             break;
         }

impl/rust-cli/tests/trap_firing_tests.rs

@@ -0,0 +1,133 @@
+// SPDX-License-Identifier: PMPL-1.0-or-later
+//! Tests for trap handler execution.
+//!
+//! Verifies that:
+//! - EXIT trap fires at shell exit
+//! - INT trap fires when SIGINT is received
+//! - Trap handlers can execute shell commands
+//! - `trap -` resets signal handling
+
+use anyhow::Result;
+use tempfile::tempdir;
+use vsh::executable::{self, ExecutableCommand};
+use vsh::parser::parse_command;
+use vsh::posix_builtins::TrapSignal;
+use vsh::state::ShellState;
+
+// -------------------------------------------------------------------------
+// Trap registration
+// -------------------------------------------------------------------------
+
+#[test]
+fn trap_set_and_retrieve() -> Result<()> {
+    let temp = tempdir()?;
+    let mut state = ShellState::new(temp.path().to_str().unwrap())?;
+
+    parse_command("trap 'echo bye' EXIT")?.execute(&mut state)?;
+
+    assert_eq!(state.traps.get(TrapSignal::Exit), Some("echo bye"));
+    assert!(state.traps.is_trapped(TrapSignal::Exit));
+    Ok(())
+}
+
+#[test]
+fn trap_reset_with_dash() -> Result<()> {
+    let temp = tempdir()?;
+    let mut state = ShellState::new(temp.path().to_str().unwrap())?;
+
+    parse_command("trap 'echo bye' EXIT")?.execute(&mut state)?;
+    assert!(state.traps.is_trapped(TrapSignal::Exit));
+
+    parse_command("trap - EXIT")?.execute(&mut state)?;
+    assert!(!state.traps.is_trapped(TrapSignal::Exit));
+    Ok(())
+}
+
+#[test]
+fn trap_set_int_handler() -> Result<()> {
+    let temp = tempdir()?;
+    let mut state = ShellState::new(temp.path().to_str().unwrap())?;
+
+    parse_command("trap 'echo caught' INT")?.execute(&mut state)?;
+
+    assert_eq!(state.traps.get(TrapSignal::Int), Some("echo caught"));
+    Ok(())
+}
+
+// -------------------------------------------------------------------------
+// INT trap firing via run_pending_traps
+// -------------------------------------------------------------------------
+
+#[test]
+fn run_pending_traps_fires_int_handler() -> Result<()> {
+    let temp = tempdir()?;
+    let mut state = ShellState::new(temp.path().to_str().unwrap())?;
+
+    // Set an INT trap that creates a directory
+    parse_command("trap 'mkdir trap_fired' INT")?.execute(&mut state)?;
+
+    // Simulate SIGINT
+    vsh::signals::request_interrupt();
+
+    // Fire pending traps
+    let should_exit = executable::run_pending_traps(&mut state);
+    assert!(!should_exit);
+
+    // The trap handler should have executed
+    assert!(state.resolve_path("trap_fired").exists());
+    Ok(())
+}
+
+#[test]
+fn run_pending_traps_no_handler_clears_flag() -> Result<()> {
+    let temp = tempdir()?;
+    let mut state = ShellState::new(temp.path().to_str().unwrap())?;
+
+    // No trap set — simulate SIGINT
+    vsh::signals::request_interrupt();
+    assert!(vsh::signals::is_interrupt_requested());
+
+    // run_pending_traps should clear the flag even with no handler
+    executable::run_pending_traps(&mut state);
+    assert!(!vsh::signals::is_interrupt_requested());
+    Ok(())
+}
+
+#[test]
+fn run_pending_traps_no_signal_is_noop() -> Result<()> {
+    let temp = tempdir()?;
+    let mut state = ShellState::new(temp.path().to_str().unwrap())?;
+
+    parse_command("trap 'mkdir should_not_exist' INT")?.execute(&mut state)?;
+
+    // No SIGINT simulated
+    vsh::signals::clear_interrupt();
+    executable::run_pending_traps(&mut state);
+
+    assert!(!state.resolve_path("should_not_exist").exists());
+    Ok(())
+}
+
+// -------------------------------------------------------------------------
+// EXIT trap firing
+// -------------------------------------------------------------------------
+
+#[test]
+fn exit_trap_is_registered_for_later_firing() -> Result<()> {
+    let temp = tempdir()?;
+    let mut state = ShellState::new(temp.path().to_str().unwrap())?;
+
+    parse_command("trap 'mkdir exit_cleanup' EXIT")?.execute(&mut state)?;
+
+    // The trap is registered but not yet fired
+    assert!(!state.resolve_path("exit_cleanup").exists());
+    assert!(state.traps.is_trapped(TrapSignal::Exit));
+
+    // Manually fire the EXIT trap (simulating shell exit)
+    if let Some(handler) = state.traps.get(TrapSignal::Exit).map(|s| s.to_string()) {
+        parse_command(&handler)?.execute(&mut state)?;
+    }
+
+    assert!(state.resolve_path("exit_cleanup").exists());
+    Ok(())
+}