feat: Phase 0 Sealing - SIGINT handling for external commands

Implemented graceful Ctrl+C handling that interrupts running external
commands without killing the shell:

Changes:
- Added ctrlc = "3.4" dependency for cross-platform signal handling
- Added INTERRUPT_REQUESTED global AtomicBool flag in main.rs
- Installed SIGINT handler in repl::run() to set interrupt flag
- Updated execute_external() to use .spawn() + polling loop
- Updated execute_external_with_redirects() with same pattern
- Added process group management on Unix for proper job control

Behavior:
- External commands now check interrupt flag every 50ms
- Ctrl+C kills child process and returns exit code 130 (128 + SIGINT)
- Shell continues running after interrupt
- No zombie processes left behind

Files changed:
- Cargo.toml: Added ctrlc dependency
- src/main.rs: Added INTERRUPT_REQUESTED static
- src/external.rs: Changed .status() → .spawn() + try_wait() loop
- src/repl.rs: Installed signal handler at REPL start
- tests/manual_sigint_test.sh: Manual verification script

Test results: 90/90 passing (no regressions)
Phase 0 Sealing: Component 1/6 complete

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

Author: hyperpolymath

impl/rust-cli/Cargo.toml

@@ -45,6 +45,9 @@ chrono = { version = "0.4", features = ["serde"] }
 # Stdout/stderr capture for redirections
 gag = "1.0"
 
+# Signal handling (Ctrl+C for external commands)
+ctrlc = "3.4"
+
 # Unix socket for BEAM IPC
 # (tokio already provides this)
 

impl/rust-cli/src/external.rs

@@ -8,6 +8,8 @@ use anyhow::{Context, Result};
 use std::fs::{File, OpenOptions};
 use std::path::PathBuf;
 use std::process::{Command, Stdio};
+use std::time::Duration;
+use std::sync::atomic::Ordering;
 
 use crate::redirection::{Redirection, RedirectSetup};
 use crate::state::ShellState;
@@ -36,40 +38,100 @@ pub fn execute_external_with_redirects(
     // PATH lookup
     let executable = find_in_path(program)?;
 
-    // Execute with redirected stdio
-    let status = Command::new(&executable)
+    // Build command with redirected stdio
+    let mut command = Command::new(&executable);
+    command
         .args(args)
         .stdin(stdin_cfg)
         .stdout(stdout_cfg)
-        .stderr(stderr_cfg)
-        .status()
-        .context(format!("Failed to execute: {}", program))?;
+        .stderr(stderr_cfg);
 
-    // Record file modifications for undo
-    redirect_setup.record_for_undo(state)?;
+    // Set process group on Unix for proper job control
+    #[cfg(unix)]
+    {
+        use std::os::unix::process::CommandExt;
+        command.process_group(0);
+    }
 
-    // Handle exit status (including signals)
-    handle_exit_status(status)
+    // Spawn child process (non-blocking)
+    let mut child = command
+        .spawn()
+        .context(format!("Failed to spawn: {}", program))?;
+
+    // Poll for exit while checking for interrupt
+    loop {
+        match child.try_wait().context("Failed to wait for child")? {
+            Some(status) => {
+                // Child exited - record modifications and return
+                redirect_setup.record_for_undo(state)?;
+                return handle_exit_status(status);
+            }
+            None => {
+                // Child still running - check for interrupt
+                if crate::INTERRUPT_REQUESTED.load(Ordering::Relaxed) {
+                    // User pressed Ctrl+C - kill child and reset flag
+                    child.kill().context("Failed to kill child process")?;
+                    crate::INTERRUPT_REQUESTED.store(false, Ordering::Relaxed);
+
+                    // Wait for child to actually terminate
+                    child.wait().context("Failed to wait for killed child")?;
+
+                    // Don't record modifications - operation interrupted
+                    return Ok(130); // 128 + SIGINT(2)
+                }
+
+                // Sleep briefly before next check
+                std::thread::sleep(Duration::from_millis(50));
+            }
+        }
+    }
 }
 
 /// Execute an external command (no redirections - legacy)
 ///
 /// Handles signal termination (SIGINT, SIGTERM) and returns appropriate exit codes.
 /// Exit code 130 indicates SIGINT (Ctrl+C), 143 indicates SIGTERM.
+///
+/// This function supports interruption via Ctrl+C - the global INTERRUPT_REQUESTED
+/// flag is checked periodically and the child process is killed if set.
 pub fn execute_external(program: &str, args: &[String]) -> Result<i32> {
     // PATH lookup
     let executable = find_in_path(program)?;
 
-    // Execute via std::process::Command
-    let status = Command::new(&executable)
+    // Spawn child process (non-blocking)
+    let mut child = Command::new(&executable)
         .args(args)
-        .stdin(Stdio::inherit()) // Pass through stdin
-        .stdout(Stdio::inherit()) // Pass through stdout
-        .stderr(Stdio::inherit()) // Pass through stderr
-        .status()
-        .context(format!("Failed to execute: {}", program))?;
+        .stdin(Stdio::inherit())
+        .stdout(Stdio::inherit())
+        .stderr(Stdio::inherit())
+        .spawn()
+        .context(format!("Failed to spawn: {}", program))?;
+
+    // Poll for exit while checking for interrupt
+    loop {
+        match child.try_wait().context("Failed to wait for child")? {
+            Some(status) => {
+                // Child exited normally
+                return handle_exit_status(status);
+            }
+            None => {
+                // Child still running - check for interrupt
+                if crate::INTERRUPT_REQUESTED.load(Ordering::Relaxed) {
+                    // User pressed Ctrl+C - kill child and reset flag
+                    child.kill().context("Failed to kill child process")?;
+                    crate::INTERRUPT_REQUESTED.store(false, Ordering::Relaxed);
+
+                    // Wait for child to actually terminate
+                    child.wait().context("Failed to wait for killed child")?;
+
+                    return Ok(130); // 128 + SIGINT(2)
+                }
 
-    handle_exit_status(status)
+                // Sleep briefly before next check
+                std::thread::sleep(Duration::from_millis(50));
+            }
+        }
+    }
 }
 
 /// Convert redirections to stdio configuration

impl/rust-cli/src/main.rs

@@ -25,6 +25,10 @@ mod state;
 use anyhow::{Context, Result};
 use clap::{Parser, Subcommand};
 use colored::Colorize;
+use std::sync::atomic::{AtomicBool, Ordering};
+
+/// Global flag set by SIGINT handler to interrupt running commands
+pub static INTERRUPT_REQUESTED: AtomicBool = AtomicBool::new(false);
 
 /// Valence Shell - Every operation is reversible
 #[derive(Parser)]

impl/rust-cli/src/repl.rs

@@ -9,13 +9,20 @@
 use anyhow::Result;
 use colored::Colorize;
 use std::io::{self, BufRead, Write};
+use std::sync::atomic::Ordering;
 
 use crate::executable::{ExecutableCommand, ExecutionResult};
 use crate::parser;
 use crate::state::ShellState;
 
 /// Run the interactive REPL
 pub fn run(state: &mut ShellState) -> Result<()> {
+    // Install SIGINT handler for graceful Ctrl+C handling
+    ctrlc::set_handler(move || {
+        crate::INTERRUPT_REQUESTED.store(true, Ordering::Relaxed);
+    })
+    .expect("Error setting Ctrl-C handler");
+
     let stdin = io::stdin();
     let mut stdout = io::stdout();
 

impl/rust-cli/tests/manual_sigint_test.sh

@@ -0,0 +1,73 @@
+#!/bin/bash
+# SPDX-License-Identifier: PLMP-1.0-or-later
+# Manual test for SIGINT (Ctrl+C) handling
+#
+# Expected behavior:
+# 1. Shell starts
+# 2. sleep 5 command runs
+# 3. Ctrl+C interrupts sleep (not shell)
+# 4. Shell remains responsive
+# 5. No zombie processes
+
+set -e
+
+echo "=== SIGINT Handling Manual Test ==="
+echo
+echo "This test will:"
+echo "1. Start vsh in interactive mode"
+echo "2. Run 'sleep 10' command"
+echo "3. Send SIGINT (Ctrl+C) after 2 seconds"
+echo "4. Verify shell is still alive"
+echo "5. Check for zombie processes"
+echo
+echo "Starting test in 3 seconds..."
+sleep 3
+
+# Build release binary
+echo "Building vsh..."
+cargo build --release --quiet
+
+# Create test script
+TEST_SCRIPT=$(mktemp)
+cat > "$TEST_SCRIPT" <<'EOF'
+sleep 10
+echo "Shell is still alive after interrupt"
+exit
+EOF
+
+# Run vsh with test script, send SIGINT after 2 seconds
+echo
+echo "Running vsh with 'sleep 10' command..."
+echo "Will send Ctrl+C after 2 seconds..."
+echo
+
+(
+    sleep 2
+    pkill -INT -f "sleep 10" || true
+    echo "  [Sent SIGINT]"
+) &
+
+timeout 15 ./target/release/vsh < "$TEST_SCRIPT" || true
+
+# Check for zombie processes
+echo
+echo "Checking for zombie processes..."
+ZOMBIES=$(ps aux | grep -E "defunct|Z" | grep -v grep || true)
+
+if [ -n "$ZOMBIES" ]; then
+    echo "❌ FAIL: Found zombie processes:"
+    echo "$ZOMBIES"
+    exit 1
+else
+    echo "✅ PASS: No zombie processes"
+fi
+
+# Cleanup
+rm -f "$TEST_SCRIPT"
+
+echo
+echo "=== Test Complete ==="
+echo "Manual verification:"
+echo "1. Sleep command should have been interrupted"
+echo "2. Shell should have printed 'Shell is still alive after interrupt'"
+echo "3. No zombie processes found"