`39abe95`

feat: add echo builtin, history expansion, and fix shell gaps

Major features:
- Add echo builtin with -n, -e, -E flags (bash-compatible)
- Implement history expansion (!!, !$, !^, !*, !-n, !n, !string)
- Add ~user expansion with passwd lookup in cd builtin
- Fix subshell stdin handling in pipelines (raw FD tracking)
- Add terminal attribute save/restore for proper cleanup
- Implement SIGHUP, SIGWINCH, SIGQUIT signal handling
- Add login shell support (-l flag, /etc/profile sourcing)

Bug fixes:
- Fix command substitution capture using fork-based approach
- Fix echo output capture in subprocesses (use locked stdout)
- Update CLAUDE.md to reflect Phase 5-6 complete status

New files:
- prompt.rs: PS1/PS1_RIGHT customizable prompts
- completion_spec.rs: per-command completion specifications

Authored by

espadonne 4 months ago

SHA: 39abe956d7464ec950329f6c2dd3dd32c2dbe1e9
Parents: 78b7a2f
Tree: 20dbf4a

18 changed files

Status	File	+	-
M	`Cargo.toml`	7	1
M	`crates/rush-cli/src/main.rs`	17	2
M	`crates/rush-cli/src/repl.rs`	441	11
M	`crates/rush-executor/src/command.rs`	596	14
M	`crates/rush-executor/src/command_subst_exec.rs`	84	56
M	`crates/rush-executor/src/lib.rs`	1	1
M	`crates/rush-executor/src/pipeline.rs`	47	16
M	`crates/rush-expand/src/context.rs`	8	0
M	`crates/rush-interactive/Cargo.toml`	6	0
M	`crates/rush-interactive/src/completer.rs`	144	12
A	`crates/rush-interactive/src/completion_spec.rs`	353	0
M	`crates/rush-interactive/src/highlighter.rs`	8	1
M	`crates/rush-interactive/src/lib.rs`	7	0
A	`crates/rush-interactive/src/prompt.rs`	257	0
M	`crates/rush-job/src/job.rs`	22	0
M	`crates/rush-job/src/lib.rs`	5	2
M	`crates/rush-job/src/signals.rs`	40	1
M	`crates/rush-job/src/terminal.rs`	39	0

Cargo.tomlmodified

  nu-ansi-term = "0.50"
  # System calls (Unix)
 -nix = { version = "0.29", features = ["process", "signal", "term", "fs", "resource"] }
 +nix = { version = "0.29", features = ["process", "signal", "term", "fs", "resource", "user"] }
  # Pattern matching
  globset = "0.4"
  clap = { version = "4.5", features = ["derive"] }
  dirs = "5.0"
 +# Time/Date
 +chrono = "0.4"
++
 +# System info
 +hostname = "0.4"
++
  # Testing
  proptest = "1.4"

crates/rush-cli/src/main.rsmodified

      #[arg(short = 'c', value_name = "COMMAND")]
      command: Option<String>,
 +    /// Run as a login shell
 +    #[arg(short = 'l', long = "login")]
 +    login: bool,
++
      /// Script file to execute
      #[arg(value_name = "FILE")]
      file: Option<String>,
              eprintln!("rush: warning: failed to set up job control: {}", e);
+         }
 -        repl::run_interactive()
 +        // Check if this is a login shell (either -l flag or argv[0] starts with '-')
 +        let is_login = cli.login || std::env::args().next()
 +            .map(|arg| arg.starts_with('-'))
 +            .unwrap_or(false);
++
 +        repl::run_interactive(is_login)
      } else {
          // Non-interactive mode (stdin)
          execute_stdin()
  /// Set up the shell for interactive use with job control
  #[cfg(unix)]
  fn setup_interactive_shell() -> Result<(), String> {
 -    use rush_job::setup_shell_terminal;
 +    use rush_job::{save_terminal_attrs, setup_job_control_signals, setup_shell_terminal};
++
 +    // Save terminal attributes for later restoration
 +    save_terminal_attrs().map_err(|e| format!("save terminal attrs: {}", e))?;
      // Put shell in its own process group and take terminal control
      setup_shell_terminal().map_err(|e| e.to_string())?;
 +    // Set up job control signals (SIGWINCH, SIGHUP, SIGQUIT, etc.)
 +    setup_job_control_signals().map_err(|e| format!("job control signals: {}", e))?;
++
      Ok(())
+ }

crates/rush-cli/src/repl.rsmodified

  use reedline::{
 -    ColumnarMenu, DefaultPrompt, Emacs, FileBackedHistory,
 +    ColumnarMenu, Emacs, FileBackedHistory,
      KeyCode, KeyModifiers, MenuBuilder, Reedline, ReedlineEvent, ReedlineMenu, Signal,
      default_emacs_keybindings,
  };
 -use rush_interactive::{RushCompleter, RushHighlighter, RushHinter};
 +use rush_expand::Context;
 +use rush_interactive::{RushCompleter, RushHighlighter, RushHinter, RushPrompt};
  use std::process::ExitCode;
 -pub fn run_interactive() -> ExitCode {
 +/// Expand history references in a command line
 +///
 +/// Supports:
 +/// - `!!` - previous command
 +/// - `!$` - last argument of previous command
 +/// - `!^` - first argument of previous command
 +/// - `!*` - all arguments of previous command
 +/// - `!-n` - nth previous command
 +/// - `!n` - command at history index n
 +/// - `!string` - most recent command starting with string
 +fn expand_history(input: &str, history: &[String]) -> Result<String, String> {
 +    if !input.contains('!') {
 +        return Ok(input.to_string());
 +    }
++
 +    let mut result = String::new();
 +    let mut chars = input.chars().peekable();
 +    let mut in_single_quote = false;
 +    let mut in_double_quote = false;
++
 +    while let Some(c) = chars.next() {
 +        match c {
 +            '\'' if !in_double_quote => {
 +                in_single_quote = !in_single_quote;
 +                result.push(c);
 +            }
 +            '"' if !in_single_quote => {
 +                in_double_quote = !in_double_quote;
 +                result.push(c);
 +            }
 +            '!' if !in_single_quote => {
 +                // Check for escaped !
 +                if let Some(&next) = chars.peek() {
 +                    match next {
 +                        '!' => {
 +                            // !! - previous command
 +                            chars.next();
 +                            if history.is_empty() {
 +                                return Err("!!: event not found".to_string());
 +                            }
 +                            result.push_str(&history[history.len() - 1]);
 +                        }
 +                        '$' => {
 +                            // !$ - last argument of previous command
 +                            chars.next();
 +                            if history.is_empty() {
 +                                return Err("!$: event not found".to_string());
 +                            }
 +                            let prev = &history[history.len() - 1];
 +                            let args: Vec<&str> = prev.split_whitespace().collect();
 +                            if let Some(last) = args.last() {
 +                                result.push_str(last);
 +                            }
 +                        }
 +                        '^' => {
 +                            // !^ - first argument of previous command
 +                            chars.next();
 +                            if history.is_empty() {
 +                                return Err("!^: event not found".to_string());
 +                            }
 +                            let prev = &history[history.len() - 1];
 +                            let args: Vec<&str> = prev.split_whitespace().collect();
 +                            if args.len() > 1 {
 +                                result.push_str(args[1]);
 +                            }
 +                        }
 +                        '*' => {
 +                            // !* - all arguments of previous command
 +                            chars.next();
 +                            if history.is_empty() {
 +                                return Err("!*: event not found".to_string());
 +                            }
 +                            let prev = &history[history.len() - 1];
 +                            let args: Vec<&str> = prev.split_whitespace().collect();
 +                            if args.len() > 1 {
 +                                result.push_str(&args[1..].join(" "));
 +                            }
 +                        }
 +                        '-' => {
 +                            // !-n - nth previous command
 +                            chars.next();
 +                            let mut num_str = String::new();
 +                            while let Some(&ch) = chars.peek() {
 +                                if ch.is_ascii_digit() {
 +                                    num_str.push(chars.next().unwrap());
 +                                } else {
 +                                    break;
 +                                }
 +                            }
 +                            if let Ok(n) = num_str.parse::<usize>() {
 +                                if n > 0 && n <= history.len() {
 +                                    result.push_str(&history[history.len() - n]);
 +                                } else {
 +                                    return Err(format!("!-{}: event not found", n));
 +                                }
 +                            } else {
 +                                return Err(format!("!-{}: event not found", num_str));
 +                            }
 +                        }
 +                        d if d.is_ascii_digit() => {
 +                            // !n - command at index n
 +                            let mut num_str = String::new();
 +                            while let Some(&ch) = chars.peek() {
 +                                if ch.is_ascii_digit() {
 +                                    num_str.push(chars.next().unwrap());
 +                                } else {
 +                                    break;
 +                                }
 +                            }
 +                            if let Ok(n) = num_str.parse::<usize>() {
 +                                if n > 0 && n <= history.len() {
 +                                    result.push_str(&history[n - 1]);
 +                                } else {
 +                                    return Err(format!("!{}: event not found", n));
 +                                }
 +                            } else {
 +                                return Err(format!("!{}: event not found", num_str));
 +                            }
 +                        }
 +                        ch if ch.is_alphanumeric() || ch == '_' => {
 +                            // !string - most recent command starting with string
 +                            let mut prefix = String::new();
 +                            while let Some(&ch) = chars.peek() {
 +                                if ch.is_alphanumeric() || ch == '_' || ch == '-' || ch == '.' {
 +                                    prefix.push(chars.next().unwrap());
 +                                } else {
 +                                    break;
 +                                }
 +                            }
 +                            // Find most recent command starting with prefix
 +                            if let Some(cmd) = history.iter().rev().find(|h| h.starts_with(&prefix)) {
 +                                result.push_str(cmd);
 +                            } else {
 +                                return Err(format!("!{}: event not found", prefix));
 +                            }
 +                        }
 +                        ' ' | '\t' | '\n' => {
 +                            // Standalone ! followed by whitespace - literal
 +                            result.push('!');
 +                        }
 +                        _ => {
 +                            // Unknown ! sequence - keep as is
 +                            result.push('!');
 +                        }
 +                    }
 +                } else {
 +                    // ! at end of line - literal
 +                    result.push('!');
 +                }
 +            }
 +            _ => {
 +                result.push(c);
 +            }
 +        }
 +    }
++
 +    Ok(result)
 +}
++
 +/// Get history as a vector of strings from reedline history
 +fn get_history_strings(line_editor: &Reedline) -> Vec<String> {
 +    let history = line_editor.history();
++
 +    // Try to get all history items (no session filtering)
 +    match history.search(reedline::SearchQuery::last_with_search(
 +        reedline::SearchFilter::anything(None),
 +    )) {
 +        Ok(items) => items.into_iter().map(|item| item.command_line).collect(),
 +        Err(_) => Vec::new(),
 +    }
 +}
++
 +/// Default config file contents
 +const DEFAULT_CONFIG: &str = r#"# Rush shell configuration
 +# This file is sourced on interactive shell startup
++
 +# Example aliases
 +# alias ll='ls -la'
 +# alias la='ls -A'
++
 +# Example prompt customization (uncomment to use)
 +# export PS1='\u@\h:\w\$ '
 +# export PS1_RIGHT='\D{%m/%d/%Y %I:%M:%S %p}'
++
 +# Example environment variables
 +# export EDITOR=vim
 +"#;
++
 +/// Check if a config file exists
 +fn config_exists() -> bool {
 +    let config_paths = [
 +        dirs::home_dir().map(|p| p.join(".rushrc")),
 +        dirs::config_dir().map(|p| p.join("rush").join("rushrc")),
 +    ];
++
 +    config_paths.iter().flatten().any(|p| p.exists())
 +}
++
 +/// Prompt user to create default config on first run
 +fn maybe_create_default_config() {
 +    if config_exists() {
 +        return;
 +    }
++
 +    // Check if we've already asked (store a marker file)
 +    let marker_path = dirs::data_dir().map(|p| p.join("rush").join(".config_prompted"));
 +    if let Some(ref marker) = marker_path {
 +        if marker.exists() {
 +            return;
 +        }
 +    }
++
 +    println!("Welcome to Rush! No configuration file found.");
 +    print!("Create default config at ~/.rushrc? [Y/n] ");
++
 +    // Flush stdout to ensure prompt is displayed
 +    use std::io::Write;
 +    std::io::stdout().flush().ok();
++
 +    let mut input = String::new();
 +    if std::io::stdin().read_line(&mut input).is_ok() {
 +        let response = input.trim().to_lowercase();
 +        if response.is_empty() || response == "y" || response == "yes" {
 +            // Create the config file
 +            if let Some(config_path) = dirs::home_dir().map(|p| p.join(".rushrc")) {
 +                match std::fs::write(&config_path, DEFAULT_CONFIG) {
 +                    Ok(_) => println!("Created {}. Edit it to customize your shell!", config_path.display()),
 +                    Err(e) => eprintln!("rush: could not create config: {}", e),
 +                }
 +            }
 +        } else {
 +            println!("Skipped. You can create ~/.rushrc manually anytime.");
 +        }
 +    }
++
 +    // Create marker so we don't ask again
 +    if let Some(marker) = marker_path {
 +        if let Some(parent) = marker.parent() {
 +            std::fs::create_dir_all(parent).ok();
 +        }
 +        std::fs::write(marker, "").ok();
 +    }
++
 +    println!();
 +}
++
 +/// Source config files on interactive shell startup
 +fn source_config_files(context: &mut Context) {
 +    let config_paths = [
 +        dirs::home_dir().map(|p| p.join(".rushrc")),
 +        dirs::config_dir().map(|p| p.join("rush").join("rushrc")),
 +    ];
++
 +    for path_opt in config_paths {
 +        if let Some(path) = path_opt {
 +            if path.exists() {
 +                match std::fs::read_to_string(&path) {
 +                    Ok(content) => {
 +                        // Filter out comment-only and empty lines, then parse
 +                        let executable_lines: Vec<&str> = content
 +                            .lines()
 +                            .filter(|line| {
 +                                let trimmed = line.trim();
 +                                !trimmed.is_empty() && !trimmed.starts_with('#')
 +                            })
 +                            .collect();
++
 +                        // Skip if no executable content
 +                        if executable_lines.is_empty() {
 +                            break;
 +                        }
++
 +                        let filtered_content = executable_lines.join("\n");
++
 +                        // Parse and execute the config file
 +                        use rush_parser::parse_line;
 +                        match parse_line(&filtered_content) {
 +                            Ok(statement) => {
 +                                if let Err(e) = rush_executor::execute_statement(&statement, context) {
 +                                    eprintln!("rush: error in {:?}: {}", path, e);
 +                                }
 +                            }
 +                            Err(e) => {
 +                                eprintln!("rush: parse error in {:?}: {}", path, e);
 +                            }
 +                        }
 +                    }
 +                    Err(e) => {
 +                        eprintln!("rush: could not read {:?}: {}", path, e);
 +                    }
 +                }
 +                break; // Only source first found config
 +            }
 +        }
 +    }
 +}
++
 +/// Source login shell profile files
 +fn source_login_profiles(context: &mut Context) {
 +    let profile_paths = [
 +        // System-wide profile
 +        Some(std::path::PathBuf::from("/etc/profile")),
 +        // User profile (traditional)
 +        dirs::home_dir().map(|p| p.join(".profile")),
 +        // Rush-specific login profile
 +        dirs::home_dir().map(|p| p.join(".rush_profile")),
 +    ];
++
 +    for path_opt in profile_paths {
 +        if let Some(path) = path_opt {
 +            if path.exists() {
 +                match std::fs::read_to_string(&path) {
 +                    Ok(content) => {
 +                        // Filter comments and empty lines
 +                        let executable_lines: Vec<&str> = content
 +                            .lines()
 +                            .filter(|line| {
 +                                let trimmed = line.trim();
 +                                !trimmed.is_empty() && !trimmed.starts_with('#')
 +                            })
 +                            .collect();
++
 +                        if executable_lines.is_empty() {
 +                            continue;
 +                        }
++
 +                        let filtered_content = executable_lines.join("\n");
++
 +                        use rush_parser::parse_line;
 +                        match parse_line(&filtered_content) {
 +                            Ok(statement) => {
 +                                if let Err(e) = rush_executor::execute_statement(&statement, context) {
 +                                    eprintln!("rush: error in {:?}: {}", path, e);
 +                                }
 +                            }
 +                            Err(e) => {
 +                                eprintln!("rush: parse error in {:?}: {}", path, e);
 +                            }
 +                        }
 +                    }
 +                    Err(e) => {
 +                        // Only warn for user profiles, not system ones
 +                        if path.starts_with(dirs::home_dir().unwrap_or_default()) {
 +                            eprintln!("rush: could not read {:?}: {}", path, e);
 +                        }
 +                    }
 +                }
 +            }
 +        }
 +    }
 +}
++
 +pub fn run_interactive(is_login: bool) -> ExitCode {
 +    // On first run, offer to create default config
 +    maybe_create_default_config();
++
      // Set up persistent history
 -    let history_file = dirs::data_dir()
 +    let history_path = dirs::data_dir()
          .map(|mut path| {
              path.push("rush");
 -            std::fs::create_dir_all(&path).ok();
 +            if let Err(e) = std::fs::create_dir_all(&path) {
 +                eprintln!("rush: warning: could not create data directory: {}", e);
 +            }
              path.push("history.txt");
              path
 -        })
 -        .and_then(|path| {
 -            FileBackedHistory::with_file(1000, path).ok()
          });
 +    let history_file = history_path.as_ref().and_then(|path| {
 +        match FileBackedHistory::with_file(1000, path.clone()) {
 +            Ok(history) => Some(history),
 +            Err(e) => {
 +                eprintln!("rush: warning: could not load history from {:?}: {}", path, e);
 +                None
 +            }
 +        }
 +    });
++
      // Create the completion menu with custom marker (instead of default "|")
      let completion_menu = Box::new(
          ColumnarMenu::default()
          line_editor = line_editor.with_history(Box::new(history));
+     }
 -    let prompt = DefaultPrompt::default();
 +    let prompt = RushPrompt::new();
      let mut context = crate::create_context();
 +    // Source login profile files if this is a login shell
 +    if is_login {
 +        source_login_profiles(&mut context);
 +    }
++
 +    // Source config files (~/.rushrc or ~/.config/rush/rushrc)
 +    source_config_files(&mut context);
++
      loop {
 +        // Check for SIGHUP (terminal hangup)
 +        #[cfg(unix)]
 +        if rush_job::check_sighup() {
 +            // Send SIGHUP to all jobs and exit
 +            context.job_list.send_hup_to_all();
 +            break;
 +        }
++
          // Check for completed/stopped background jobs before each prompt
          #[cfg(unix)]
          crate::check_background_jobs(&mut context);
                      continue;
+                 }
 -                if let Err(e) = crate::execute_interactive_line(&buffer, &mut context) {
 +                // Perform history expansion if the line contains !
 +                let expanded_buffer = if buffer.contains('!') {
 +                    let history = get_history_strings(&line_editor);
 +                    match expand_history(&buffer, &history) {
 +                        Ok(expanded) => {
 +                            // If expansion changed the line, print it (bash behavior)
 +                            if expanded != buffer {
 +                                println!("{}", expanded);
 +                            }
 +                            expanded
 +                        }
 +                        Err(e) => {
 +                            eprintln!("rush: {}", e);
 +                            continue;
 +                        }
 +                    }
 +                } else {
 +                    buffer
 +                };
++
 +                if let Err(e) = crate::execute_interactive_line(&expanded_buffer, &mut context) {
                      eprintln!("rush: {}", e);
+                 }
++
 +                // Check if exit was requested
 +                if context.exit_requested.is_some() {
 +                    break;
 +                }
+             }
              Ok(Signal::CtrlD) | Ok(Signal::CtrlC) => {
                  break;
+             }
              Err(e) => {
                  eprintln!("rush: error: {}", e);
 +                // Sync history before returning on error
 +                if let Err(e) = line_editor.sync_history() {
 +                    eprintln!("rush: warning: failed to save history: {}", e);
 +                }
 +                // Restore terminal attributes
 +                #[cfg(unix)]
 +                if let Err(e) = rush_job::restore_terminal_attrs() {
 +                    eprintln!("rush: warning: failed to restore terminal: {}", e);
 +                }
                  return ExitCode::from(1);
+             }
+         }
+     }
 -    ExitCode::SUCCESS
 +    // Sync history before exiting
 +    if let Err(e) = line_editor.sync_history() {
 +        eprintln!("rush: warning: failed to save history: {}", e);
 +    }
++
 +    // Restore terminal attributes to their original state
 +    #[cfg(unix)]
 +    if let Err(e) = rush_job::restore_terminal_attrs() {
 +        eprintln!("rush: warning: failed to restore terminal: {}", e);
 +    }
++
 +    // Return requested exit code, or SUCCESS
 +    match context.exit_requested {
 +        Some(code) => ExitCode::from(code as u8),
 +        None => ExitCode::SUCCESS,
 +    }
+ }

crates/rush-executor/src/command.rsmodified

          "exit" => {
              let code = args.first()
                  .and_then(|s| s.parse::<i32>().ok())
 -                .unwrap_or(0);
 -            std::process::exit(code);
 +                .unwrap_or(context.last_exit_status);
 +            context.exit_requested = Some(code);
 +            Some(exit_code_to_result(code))
+         }
          "true" => Some(success_result()),
          "false" => Some(error_result()),
          ":" => Some(success_result()),
 -        "cd" => {
 -            let default_home = env::var("HOME").unwrap_or_else(|_| "/".to_string());
 -            let dir = args.first()
 -                .map(|s| s.as_str())
 -                .unwrap_or(&default_home);
+-
 -            match env::set_current_dir(dir) {
 -                Ok(_) => Some(success_result()),
 -                Err(_) => Some(error_result()),
 -            }
 -        }
 +        "cd" => Some(builtin_cd(args, context)),
          "pwd" => {
              match env::current_dir() {
                  Ok(path) => {
              eprintln!("{}: job control not supported on this platform", command);
              Some(error_result())
+         }
 +        "echo" => Some(builtin_echo(args)),
          "printf" => Some(builtin_printf(args, context)),
          "mapfile" | "readarray" => Some(builtin_mapfile(args, context)),
 +        "complete" => Some(builtin_complete(args, context)),
 +        "pushd" => Some(builtin_pushd(args, context)),
 +        "popd" => Some(builtin_popd(args, context)),
 +        "dirs" => Some(builtin_dirs(args, context)),
          _ => None,
+     }
+ }
+     }
+ }
 +/// cd builtin - change directory
 +/// Supports: cd, cd -, cd ~, cd ~user, cd /path
 +fn builtin_cd(args: &[String], context: &mut rush_expand::Context) -> ExecutionResult {
 +    let home = env::var("HOME").unwrap_or_else(|_| "/".to_string());
++
 +    // Get target directory
 +    let target = if args.is_empty() {
 +        // cd with no args goes to $HOME
 +        home.clone()
 +    } else {
 +        let arg = &args[0];
 +        if arg == "-" {
 +            // cd - goes to $OLDPWD
 +            match context.get_var("OLDPWD") {
 +                Some(oldpwd) => {
 +                    println!("{}", oldpwd);
 +                    oldpwd.to_string()
 +                }
 +                None => {
 +                    eprintln!("cd: OLDPWD not set");
 +                    return error_result();
 +                }
 +            }
 +        } else if arg == "~" || arg.is_empty() {
 +            // cd ~ goes to $HOME
 +            home.clone()
 +        } else if arg.starts_with("~/") {
 +            // cd ~/path goes to $HOME/path
 +            format!("{}/{}", home, &arg[2..])
 +        } else if arg.starts_with('~') {
 +            // cd ~user - lookup user's home directory
 +            let (username, suffix) = if let Some(slash_pos) = arg.find('/') {
 +                (&arg[1..slash_pos], &arg[slash_pos..])
 +            } else {
 +                (&arg[1..], "")
 +            };
++
 +            #[cfg(unix)]
 +            {
 +                use nix::unistd::User;
 +                match User::from_name(username) {
 +                    Ok(Some(user)) => {
 +                        let home = user.dir.to_string_lossy();
 +                        if suffix.is_empty() {
 +                            home.to_string()
 +                        } else {
 +                            format!("{}{}", home, suffix)
 +                        }
 +                    }
 +                    Ok(None) => {
 +                        eprintln!("cd: ~{}: No such user", username);
 +                        return error_result();
 +                    }
 +                    Err(e) => {
 +                        eprintln!("cd: ~{}: {}", username, e);
 +                        return error_result();
 +                    }
 +                }
 +            }
 +            #[cfg(not(unix))]
 +            {
 +                // On non-Unix platforms, just treat as literal path
 +                arg.clone()
 +            }
 +        } else {
 +            arg.clone()
 +        }
 +    };
++
 +    // Save current directory as OLDPWD before changing
 +    if let Ok(cwd) = env::current_dir() {
 +        let _ = context.set_var("OLDPWD", cwd.to_string_lossy().to_string());
 +    }
++
 +    // Change directory
 +    match env::set_current_dir(&target) {
 +        Ok(_) => {
 +            // Update PWD
 +            if let Ok(new_cwd) = env::current_dir() {
 +                let _ = context.set_var("PWD", new_cwd.to_string_lossy().to_string());
 +            }
 +            success_result()
 +        }
 +        Err(e) => {
 +            eprintln!("cd: {}: {}", target, e);
 +            error_result()
 +        }
 +    }
 +}
++
 +/// pushd builtin - push directory onto stack and cd to it
 +fn builtin_pushd(args: &[String], context: &mut rush_expand::Context) -> ExecutionResult {
 +    // Get current directory first
 +    let cwd = match env::current_dir() {
 +        Ok(p) => p.to_string_lossy().to_string(),
 +        Err(e) => {
 +            eprintln!("pushd: error getting current directory: {}", e);
 +            return error_result();
 +        }
 +    };
++
 +    if args.is_empty() {
 +        // pushd with no args swaps top two directories
 +        if context.dir_stack.is_empty() {
 +            eprintln!("pushd: no other directory");
 +            return error_result();
 +        }
++
 +        let top = context.dir_stack.remove(0);
 +        context.dir_stack.insert(0, cwd.clone());
++
 +        // Change to the popped directory
 +        if let Err(e) = env::set_current_dir(&top) {
 +            // Restore stack on failure
 +            context.dir_stack.remove(0);
 +            context.dir_stack.insert(0, top);
 +            eprintln!("pushd: {}", e);
 +            return error_result();
 +        }
++
 +        // Update OLDPWD and PWD
 +        let _ = context.set_var("OLDPWD", cwd);
 +        let _ = context.set_var("PWD", top.clone());
++
 +        // Print the stack
 +        print_dir_stack(context);
 +        success_result()
 +    } else {
 +        let target = &args[0];
++
 +        // Expand ~ in target
 +        let expanded = if target == "~" {
 +            env::var("HOME").unwrap_or_else(|_| "/".to_string())
 +        } else if target.starts_with("~/") {
 +            let home = env::var("HOME").unwrap_or_else(|_| "/".to_string());
 +            format!("{}/{}", home, &target[2..])
 +        } else {
 +            target.clone()
 +        };
++
 +        // Push current directory onto stack
 +        context.dir_stack.insert(0, cwd.clone());
++
 +        // Change to new directory
 +        if let Err(e) = env::set_current_dir(&expanded) {
 +            // Remove the directory we just pushed on failure
 +            context.dir_stack.remove(0);
 +            eprintln!("pushd: {}: {}", expanded, e);
 +            return error_result();
 +        }
++
 +        // Update OLDPWD and PWD
 +        let _ = context.set_var("OLDPWD", cwd);
 +        if let Ok(new_cwd) = env::current_dir() {
 +            let _ = context.set_var("PWD", new_cwd.to_string_lossy().to_string());
 +        }
++
 +        // Print the stack
 +        print_dir_stack(context);
 +        success_result()
 +    }
 +}
++
 +/// popd builtin - pop directory from stack and cd to it
 +fn builtin_popd(args: &[String], context: &mut rush_expand::Context) -> ExecutionResult {
 +    // Check for -n flag (don't change directory, just manipulate stack)
 +    let no_cd = args.iter().any(|a| a == "-n");
++
 +    if context.dir_stack.is_empty() {
 +        eprintln!("popd: directory stack empty");
 +        return error_result();
 +    }
++
 +    let dir = context.dir_stack.remove(0);
++
 +    if !no_cd {
 +        // Save current directory as OLDPWD
 +        if let Ok(cwd) = env::current_dir() {
 +            let _ = context.set_var("OLDPWD", cwd.to_string_lossy().to_string());
 +        }
++
 +        // Change to the popped directory
 +        if let Err(e) = env::set_current_dir(&dir) {
 +            // Re-add directory to stack on failure
 +            context.dir_stack.insert(0, dir);
 +            eprintln!("popd: {}", e);
 +            return error_result();
 +        }
++
 +        // Update PWD
 +        if let Ok(new_cwd) = env::current_dir() {
 +            let _ = context.set_var("PWD", new_cwd.to_string_lossy().to_string());
 +        }
 +    }
++
 +    // Print the stack
 +    print_dir_stack(context);
 +    success_result()
 +}
++
 +/// dirs builtin - display directory stack
 +fn builtin_dirs(args: &[String], context: &mut rush_expand::Context) -> ExecutionResult {
 +    let clear = args.iter().any(|a| a == "-c");
 +    let print_index = args.iter().any(|a| a == "-v");
 +    let one_per_line = args.iter().any(|a| a == "-p");
++
 +    if clear {
 +        context.dir_stack.clear();
 +        return success_result();
 +    }
++
 +    // Get current directory
 +    let cwd = env::current_dir()
 +        .map(|p| p.to_string_lossy().to_string())
 +        .unwrap_or_else(|_| ".".to_string());
++
 +    if print_index {
 +        // Print with indices
 +        println!(" 0  {}", cwd);
 +        for (i, dir) in context.dir_stack.iter().enumerate() {
 +            println!(" {}  {}", i + 1, dir);
 +        }
 +    } else if one_per_line {
 +        // One directory per line
 +        println!("{}", cwd);
 +        for dir in &context.dir_stack {
 +            println!("{}", dir);
 +        }
 +    } else {
 +        // Default: space-separated on one line
 +        print_dir_stack(context);
 +    }
++
 +    success_result()
 +}
++
 +/// Helper to print the directory stack
 +fn print_dir_stack(context: &rush_expand::Context) {
 +    let cwd = env::current_dir()
 +        .map(|p| p.to_string_lossy().to_string())
 +        .unwrap_or_else(|_| ".".to_string());
++
 +    let mut parts = vec![cwd];
 +    parts.extend(context.dir_stack.iter().cloned());
 +    println!("{}", parts.join(" "));
 +}
++
 +/// echo builtin - display a line of text
 +///
 +/// Uses direct writes to stdout for reliable capture in command substitution
 +fn builtin_echo(args: &[String]) -> ExecutionResult {
 +    use std::io::Write;
++
 +    let mut newline = true;
 +    let mut interpret_escapes = false;
 +    let mut args_iter = args.iter().peekable();
++
 +    // Parse options (bash-style: only at the start, stop at first non-option)
 +    while let Some(arg) = args_iter.peek() {
 +        if arg.starts_with('-') && arg.len() > 1 && arg.chars().skip(1).all(|c| matches!(c, 'n' | 'e' | 'E')) {
 +            let arg = args_iter.next().unwrap();
 +            for c in arg.chars().skip(1) {
 +                match c {
 +                    'n' => newline = false,
 +                    'e' => interpret_escapes = true,
 +                    'E' => interpret_escapes = false,
 +                    _ => {}
 +                }
 +            }
 +        } else {
 +            break;
 +        }
 +    }
++
 +    let remaining: Vec<&String> = args_iter.collect();
 +    let text = remaining.iter().map(|s| s.as_str()).collect::<Vec<_>>().join(" ");
++
 +    // Get stdout handle and lock it for the duration of the write
 +    let stdout = std::io::stdout();
 +    let mut handle = stdout.lock();
++
 +    if interpret_escapes {
 +        let mut output = String::new();
 +        let mut chars = text.chars().peekable();
 +        while let Some(c) = chars.next() {
 +            if c == '\\' {
 +                match chars.next() {
 +                    Some('n') => output.push('\n'),
 +                    Some('t') => output.push('\t'),
 +                    Some('r') => output.push('\r'),
 +                    Some('\\') => output.push('\\'),
 +                    Some('a') => output.push('\x07'),
 +                    Some('b') => output.push('\x08'),
 +                    Some('f') => output.push('\x0C'),
 +                    Some('v') => output.push('\x0B'),
 +                    Some('0') => {
 +                        // Octal escape
 +                        let mut oct = String::new();
 +                        for _ in 0..3 {
 +                            if let Some(&ch) = chars.peek() {
 +                                if ch >= '0' && ch <= '7' {
 +                                    oct.push(chars.next().unwrap());
 +                                } else {
 +                                    break;
 +                                }
 +                            }
 +                        }
 +                        let val = u8::from_str_radix(&oct, 8).unwrap_or(0);
 +                        output.push(val as char);
 +                    }
 +                    Some('x') => {
 +                        // Hex escape
 +                        let mut hex = String::new();
 +                        for _ in 0..2 {
 +                            if let Some(&ch) = chars.peek() {
 +                                if ch.is_ascii_hexdigit() {
 +                                    hex.push(chars.next().unwrap());
 +                                } else {
 +                                    break;
 +                                }
 +                            }
 +                        }
 +                        if !hex.is_empty() {
 +                            let val = u8::from_str_radix(&hex, 16).unwrap_or(0);
 +                            output.push(val as char);
 +                        } else {
 +                            output.push_str("\\x");
 +                        }
 +                    }
 +                    Some('c') => {
 +                        // Stop output (no newline either)
 +                        let _ = handle.write_all(output.as_bytes());
 +                        let _ = handle.flush();
 +                        return success_result();
 +                    }
 +                    Some(other) => {
 +                        output.push('\\');
 +                        output.push(other);
 +                    }
 +                    None => output.push('\\'),
 +                }
 +            } else {
 +                output.push(c);
 +            }
 +        }
 +        let _ = handle.write_all(output.as_bytes());
 +    } else {
 +        let _ = handle.write_all(text.as_bytes());
 +    }
++
 +    if newline {
 +        let _ = handle.write_all(b"\n");
 +    }
++
 +    let _ = handle.flush();
 +    success_result()
 +}
++
  /// printf builtin - formatted output
  fn builtin_printf(args: &[String], _context: &mut rush_expand::Context) -> ExecutionResult {
      if args.is_empty() {
+ }
  /// Helper to execute a parsed statement
 -fn execute_statement(
 +pub fn execute_statement(
      statement: &rush_parser::Statement,
      context: &mut rush_expand::Context,
  ) -> Result<ExecutionResult, String> {
+     }
+ }
 +/// `complete` builtin - Define command-specific completions
 +///
 +/// Usage:
 +///   complete -c COMMAND [-a COMPLETIONS] [-d DESC] [-s SHORT] [-l LONG] [-f] [-n COND]
 +///   complete -c COMMAND -e    # Erase completions
 +///   complete -p               # Print all completions
 +///   complete -c COMMAND -p    # Print completions for COMMAND
 +///
 +/// Options:
 +///   -c COMMAND    The command to add completions for
 +///   -a ARGS       Completions to add (space-separated, or command in parentheses)
 +///   -d DESC       Description for the completion
 +///   -s SHORT      Short option (e.g., -v)
 +///   -l LONG       Long option (e.g., --verbose)
 +///   -f            Disable file completion for this command
 +///   -n COND       Condition for when this completion applies
 +///   -e            Erase all completions for the command
 +///   -p            Print completions
 +fn builtin_complete(args: &[String], _context: &rush_expand::Context) -> ExecutionResult {
 +    use rush_interactive::{
 +        add_completion, remove_completions, with_registry,
 +        CompletionSource, CompletionSpec,
 +    };
++
 +    let mut command: Option<String> = None;
 +    let mut completions: Option<String> = None;
 +    let mut description: Option<String> = None;
 +    let mut short_opt: Option<char> = None;
 +    let mut long_opt: Option<String> = None;
 +    let mut no_files = false;
 +    let mut condition: Option<String> = None;
 +    let mut erase = false;
 +    let mut print = false;
++
 +    // Parse arguments
 +    let mut i = 0;
 +    while i < args.len() {
 +        let arg = &args[i];
 +        match arg.as_str() {
 +            "-c" => {
 +                i += 1;
 +                if i < args.len() {
 +                    command = Some(args[i].clone());
 +                } else {
 +                    eprintln!("complete: -c requires an argument");
 +                    return error_result();
 +                }
 +            }
 +            "-a" => {
 +                i += 1;
 +                if i < args.len() {
 +                    completions = Some(args[i].clone());
 +                } else {
 +                    eprintln!("complete: -a requires an argument");
 +                    return error_result();
 +                }
 +            }
 +            "-d" => {
 +                i += 1;
 +                if i < args.len() {
 +                    description = Some(args[i].clone());
 +                } else {
 +                    eprintln!("complete: -d requires an argument");
 +                    return error_result();
 +                }
 +            }
 +            "-s" => {
 +                i += 1;
 +                if i < args.len() {
 +                    short_opt = args[i].chars().next();
 +                } else {
 +                    eprintln!("complete: -s requires an argument");
 +                    return error_result();
 +                }
 +            }
 +            "-l" => {
 +                i += 1;
 +                if i < args.len() {
 +                    long_opt = Some(args[i].clone());
 +                } else {
 +                    eprintln!("complete: -l requires an argument");
 +                    return error_result();
 +                }
 +            }
 +            "-n" => {
 +                i += 1;
 +                if i < args.len() {
 +                    condition = Some(args[i].clone());
 +                } else {
 +                    eprintln!("complete: -n requires an argument");
 +                    return error_result();
 +                }
 +            }
 +            "-f" => no_files = true,
 +            "-e" => erase = true,
 +            "-p" => print = true,
 +            _ => {
 +                eprintln!("complete: unknown option: {}", arg);
 +                return error_result();
 +            }
 +        }
 +        i += 1;
 +    }
++
 +    // Handle print mode
 +    if print {
 +        with_registry(|registry| {
 +            if let Some(cmd) = &command {
 +                // Print completions for specific command
 +                if let Some(specs) = registry.get(cmd) {
 +                    for spec in specs {
 +                        print_completion_spec(spec);
 +                    }
 +                }
 +            } else {
 +                // Print all completions
 +                for (cmd, specs) in registry.all_specs() {
 +                    println!("# Completions for '{}'", cmd);
 +                    for spec in specs {
 +                        print_completion_spec(spec);
 +                    }
 +                }
 +            }
 +        });
 +        return success_result();
 +    }
++
 +    // Handle erase mode
 +    if erase {
 +        if let Some(cmd) = command {
 +            remove_completions(&cmd);
 +            return success_result();
 +        } else {
 +            eprintln!("complete: -e requires -c COMMAND");
 +            return error_result();
 +        }
 +    }
++
 +    // Adding a completion requires a command
 +    let cmd = match command {
 +        Some(c) => c,
 +        None => {
 +            eprintln!("complete: -c COMMAND is required");
 +            return error_result();
 +        }
 +    };
++
 +    // Determine the completion source
 +    let source = if let Some(comps) = completions {
 +        // Check if it's a dynamic command (wrapped in parentheses)
 +        if comps.starts_with('(') && comps.ends_with(')') {
 +            CompletionSource::Dynamic(comps[1..comps.len()-1].to_string())
 +        } else {
 +            // Static list of completions (space-separated)
 +            CompletionSource::Static(
 +                comps.split_whitespace().map(String::from).collect()
 +            )
 +        }
 +    } else if short_opt.is_some() || long_opt.is_some() {
 +        CompletionSource::Option {
 +            short: short_opt,
 +            long: long_opt,
 +        }
 +    } else if no_files {
 +        // Just marking no-files without adding completions
 +        CompletionSource::Static(vec![])
 +    } else {
 +        eprintln!("complete: need -a, -s, -l, or -f");
 +        return error_result();
 +    };
++
 +    // Create and register the completion spec
 +    let spec = CompletionSpec {
 +        command: cmd,
 +        condition,
 +        source,
 +        description,
 +        no_files,
 +    };
++
 +    add_completion(spec);
 +    success_result()
 +}
++
 +fn print_completion_spec(spec: &rush_interactive::CompletionSpec) {
 +    use rush_interactive::CompletionSource;
++
 +    let mut parts = vec![format!("complete -c {}", spec.command)];
++
 +    if let Some(ref cond) = spec.condition {
 +        parts.push(format!("-n \"{}\"", cond));
 +    }
++
 +    match &spec.source {
 +        CompletionSource::Static(items) if !items.is_empty() => {
 +            parts.push(format!("-a \"{}\"", items.join(" ")));
 +        }
 +        CompletionSource::Dynamic(cmd) => {
 +            parts.push(format!("-a \"({})\"", cmd));
 +        }
 +        CompletionSource::ShortOption(c) => {
 +            parts.push(format!("-s {}", c));
 +        }
 +        CompletionSource::LongOption(s) => {
 +            parts.push(format!("-l {}", s));
 +        }
 +        CompletionSource::Option { short, long } => {
 +            if let Some(c) = short {
 +                parts.push(format!("-s {}", c));
 +            }
 +            if let Some(l) = long {
 +                parts.push(format!("-l {}", l));
 +            }
 +        }
 +        _ => {}
 +    }
++
 +    if let Some(ref desc) = spec.description {
 +        parts.push(format!("-d \"{}\"", desc));
 +    }
++
 +    if spec.no_files {
 +        parts.push("-f".to_string());
 +    }
++
 +    println!("{}", parts.join(" "));
 +}
++
  #[cfg(test)]
  mod tests {
      use super::*;

crates/rush-executor/src/command_subst_exec.rsmodified

  //! enabling $(command) substitution without relying on external shells.
  use rush_expand::Context;
 -use std::io::Write;
  /// Execute a command string internally and capture its stdout
  ///
  ///
  /// The function:
  /// 1. Parses the command string using rush-parser
 -/// 2. Captures stdout to a buffer
 -/// 3. Executes the command using rush-executor
 -/// 4. Returns the captured output
 +/// 2. Forks a child process
 +/// 3. The child executes the command with stdout redirected to a pipe
 +/// 4. The parent reads and returns the captured output
  pub fn execute_for_substitution(cmd: &str, context: &mut Context) -> Result<String, String> {
      // Parse the command
      let statement = rush_parser::parse_line(cmd)
          .map_err(|e| format!("Parse error: {}", e))?;
 -    // Use a pipe to capture stdout
 +    // Use fork + pipe to capture stdout (like bash does)
      #[cfg(unix)]
+     {
 -        execute_with_capture_unix(statement, context)
 +        execute_with_fork_capture(statement, context)
+     }
      #[cfg(not(unix))]
+ }
  #[cfg(unix)]
 -fn execute_with_capture_unix(
 +fn execute_with_fork_capture(
      statement: rush_parser::Statement,
      context: &mut Context,
  ) -> Result<String, String> {
      use nix::libc;
 -    use nix::unistd::{pipe, dup, dup2};
 +    use nix::unistd::{pipe, dup2, fork, ForkResult};
 +    use nix::sys::wait::{waitpid, WaitStatus};
      use std::os::unix::io::{RawFd, FromRawFd, IntoRawFd};
 -    use std::io::Read;
 +    use std::io::{Read, Write};
      const STDOUT_FD: RawFd = 1;
      // Create a pipe for capturing output
      let (read_fd, write_fd) = pipe().map_err(|e| format!("Failed to create pipe: {}", e))?;
+-
 -    // Get raw fds and take ownership to prevent automatic close
      let read_raw_fd = read_fd.into_raw_fd();
      let write_raw_fd = write_fd.into_raw_fd();
 -    // Save the original stdout
 -    let saved_stdout = dup(STDOUT_FD).map_err(|e| format!("Failed to dup stdout: {}", e))?;
 -    let saved_stdout_raw = saved_stdout.into_raw_fd();
 +    // Fork to execute the command in a subprocess
 +    match unsafe { fork() } {
 +        Ok(ForkResult::Child) => {
 +            // Child process: redirect stdout to pipe and execute
 -    // Redirect stdout to the write end of the pipe
 -    dup2(write_raw_fd, STDOUT_FD).map_err(|e| format!("Failed to redirect stdout: {}", e))?;
 +            // Close the read end of the pipe (child only writes)
 +            unsafe { libc::close(read_raw_fd); }
 -    // Close the write_fd as we've duplicated it to stdout
 -    // (write_fd is now owned by stdout, so we close the original)
 -    unsafe { libc::close(write_raw_fd); }
 +            // Redirect stdout to the write end of the pipe
 +            if let Err(_) = dup2(write_raw_fd, STDOUT_FD) {
 +                std::process::exit(1);
 +            }
 -    // Execute the command
 -    let exec_result = match statement {
 -        rush_parser::Statement::Complete(cmd) => {
 -            crate::control_flow::execute_complete_command(&cmd, context)
 -        }
 -        rush_parser::Statement::Script(commands) => {
 -            let mut last_result = crate::command::success_result();
 -            for cmd in &commands {
 -                match crate::control_flow::execute_complete_command(cmd, context) {
 -                    Ok(result) => last_result = result,
 -                    Err(e) => {
 -                        // Restore stdout before returning error
 -                        let _ = dup2(saved_stdout_raw, STDOUT_FD);
 -                        unsafe {
 -                            libc::close(saved_stdout_raw);
 -                            libc::close(read_raw_fd);
 +            // Close the original write_fd (now that stdout points to it)
 +            unsafe { libc::close(write_raw_fd); }
++
 +            // Execute the command
 +            let exit_code = match statement {
 +                rush_parser::Statement::Complete(cmd) => {
 +                    match crate::control_flow::execute_complete_command(&cmd, context) {
 +                        Ok(result) => result.exit_code(),
 +                        Err(_) => 1,
 +                    }
 +                }
 +                rush_parser::Statement::Script(commands) => {
 +                    let mut last_code = 0;
 +                    for cmd in &commands {
 +                        match crate::control_flow::execute_complete_command(cmd, context) {
 +                            Ok(result) => last_code = result.exit_code(),
 +                            Err(_) => {
 +                                last_code = 1;
 +                                break;
 +                            }
+                         }
 -                        return Err(format!("Execution error: {}", e));
+                     }
 +                    last_code
+                 }
 -            }
 -            Ok(last_result)
 +                rush_parser::Statement::Empty => 0,
 +            };
++
 +            // Ensure all output is flushed before exiting
 +            let _ = std::io::stdout().flush();
++
 +            // Exit the child process
 +            std::process::exit(exit_code);
+         }
 -        rush_parser::Statement::Empty => Ok(crate::command::success_result()),
 -    };
 +        Ok(ForkResult::Parent { child }) => {
 +            // Parent process: close write end and read from pipe
 -    // Flush stdout to ensure all data is written to the pipe
 -    let _ = std::io::stdout().flush();
 +            // Close the write end (parent only reads)
 +            unsafe { libc::close(write_raw_fd); }
 -    // Restore the original stdout
 -    dup2(saved_stdout_raw, STDOUT_FD).map_err(|e| format!("Failed to restore stdout: {}", e))?;
 -    unsafe { libc::close(saved_stdout_raw); }
 +            // Read all output from the pipe
 +            let mut output = String::new();
 +            let mut reader = unsafe { std::fs::File::from_raw_fd(read_raw_fd) };
 +            if let Err(e) = reader.read_to_string(&mut output) {
 +                return Err(format!("Failed to read output: {}", e));
 +            }
 -    // Check execution result
 -    exec_result.map_err(|e| format!("Execution error: {}", e))?;
 +            // Wait for child to complete
 +            match waitpid(child, None) {
 +                Ok(WaitStatus::Exited(_, code)) => {
 +                    context.set_exit_status(code);
 +                }
 +                Ok(_) => {
 +                    context.set_exit_status(0);
 +                }
 +                Err(e) => {
 +                    return Err(format!("Failed to wait for child: {}", e));
 +                }
 +            }
 -    // Read the captured output from the pipe
 -    let mut output = String::new();
 -    let mut reader = unsafe { std::fs::File::from_raw_fd(read_raw_fd) };
 -    reader.read_to_string(&mut output).map_err(|e| format!("Failed to read output: {}", e))?;
 +            // Bash behavior: trim trailing newlines from command substitution
 +            while output.ends_with('\n') {
 +                output.pop();
 +            }
 -    // Bash behavior: trim trailing newlines from command substitution
 -    while output.ends_with('\n') {
 -        output.pop();
 +            Ok(output)
 +        }
 +        Err(e) => {
 +            // Fork failed, clean up
 +            unsafe {
 +                libc::close(read_raw_fd);
 +                libc::close(write_raw_fd);
 +            }
 +            Err(format!("Failed to fork: {}", e))
 +        }
+     }
+-
 -    Ok(output)
+ }
  #[cfg(test)]

crates/rush-executor/src/lib.rsmodified

  pub mod test_builtin;
  pub use background::{execute_pipeline_background, execute_simple_background};
 -pub use command::{execute_command, ExecutionError, ExecutionResult};
 +pub use command::{execute_command, execute_statement, ExecutionError, ExecutionResult};
  #[cfg(unix)]
  pub use command::JobControlInfo;
  pub use command_subst_exec::execute_for_substitution;

crates/rush-executor/src/pipeline.rsmodified

+     }
      // Build and spawn all commands in the pipeline
 +    // We track raw file descriptors for proper subshell stdin handling
      let mut children = Vec::new();
 -    let mut subshell_pids = Vec::new(); // Track subshell PIDs separately
 -    let mut prev_stdout = None;
 +    let mut subshell_pids = Vec::new();
 +    #[cfg(unix)]
 +    let mut prev_stdout_fd: Option<i32> = None;
 +    #[cfg(not(unix))]
 +    let mut prev_stdout: Option<Stdio> = None;
      for (i, element) in pipeline.commands.iter().enumerate() {
          let is_first = i == 0;
                  cmd.args(args);
                  // Set up stdin
 -                if is_first {
 -                    cmd.stdin(Stdio::inherit());
 -                } else if let Some(prev_out) = prev_stdout.take() {
 -                    cmd.stdin(prev_out);
 +                #[cfg(unix)]
 +                {
 +                    use std::os::unix::io::FromRawFd;
 +                    if is_first {
 +                        cmd.stdin(Stdio::inherit());
 +                    } else if let Some(fd) = prev_stdout_fd.take() {
 +                        cmd.stdin(Stdio::from(unsafe { std::fs::File::from_raw_fd(fd) }));
 +                    }
 +                }
 +                #[cfg(not(unix))]
 +                {
 +                    if is_first {
 +                        cmd.stdin(Stdio::inherit());
 +                    } else if let Some(prev_out) = prev_stdout.take() {
 +                        cmd.stdin(prev_out);
 +                    }
+                 }
                  // Set up stdout
                  let mut child = cmd.spawn()?;
                  if !is_last {
 -                    prev_stdout = child.stdout.take().map(Stdio::from);
 +                    #[cfg(unix)]
 +                    {
 +                        use std::os::unix::io::IntoRawFd;
 +                        prev_stdout_fd = child.stdout.take().map(|f| f.into_raw_fd());
 +                    }
 +                    #[cfg(not(unix))]
 +                    {
 +                        prev_stdout = child.stdout.take().map(Stdio::from);
 +                    }
+                 }
                  children.push(child);
+             }
                  #[cfg(unix)]
+                 {
                      use nix::unistd::{fork, ForkResult, pipe as nix_pipe, dup2};
 -                    use std::os::unix::io::{IntoRawFd, FromRawFd};
 +                    use std::os::unix::io::IntoRawFd;
++
 +                    // Take stdin fd from previous command
 +                    let stdin_fd = prev_stdout_fd.take();
                      // Create pipe for stdout if not last
                      let pipe_fds = if !is_last {
                              // Child process: execute subshell with redirected I/O
                              use nix::libc;
 -                            // Set up stdin from previous command if we have one
 -                            if let Some(_prev) = prev_stdout {
 -                                // _prev is Stdio, we need to extract the file descriptor
 -                                // This is tricky - Stdio doesn't expose the raw FD easily
 -                                // We'll skip stdin redirection for now in subshells
 -                                // TODO: Properly handle stdin from previous pipeline element
 +                            // Set up stdin from previous command
 +                            if let Some(fd) = stdin_fd {
 +                                let _ = dup2(fd, 0); // Redirect stdin
 +                                unsafe { libc::close(fd); }
+                             }
                              // Set up stdout to pipe if not last
                              std::process::exit(exit_code);
+                         }
                          Ok(ForkResult::Parent { child }) => {
 -                            // Parent process: save pipe and track child PID
 +                            // Parent process: close stdin fd and save stdout pipe
                              use nix::libc;
++
 +                            // Close the stdin fd in parent (child has its own copy)
 +                            if let Some(fd) = stdin_fd {
 +                                unsafe { libc::close(fd); }
 +                            }
++
                              if let Some((read_fd, write_fd)) = pipe_fds {
                                  unsafe { libc::close(write_fd); }
 -                                prev_stdout = Some(Stdio::from(unsafe { std::fs::File::from_raw_fd(read_fd) }));
 +                                prev_stdout_fd = Some(read_fd);
+                             }
                              // Track the subshell PID for later waiting

crates/rush-expand/src/context.rsmodified

      local_scopes: Vec<HashMap<String, String>>,
      /// Exit status of last command
      pub last_exit_status: i32,
 +    /// Flag indicating the shell should exit (set by `exit` builtin)
 +    pub exit_requested: Option<i32>,
      /// Shell functions (name -> body)
      pub functions: HashMap<String, rush_parser::ast::FunctionDef>,
      /// Arrays (name -> indexed or associative)
      /// Internal command executor (for command substitution)
      /// If set, command substitution will use this instead of sh -c
      pub command_executor: CommandExecutorWrapper,
 +    /// Directory stack for pushd/popd
 +    pub dir_stack: Vec<String>,
+ }
  impl Context {
              exported: HashMap::new(),
              local_scopes: Vec::new(),
              last_exit_status: 0,
 +            exit_requested: None,
              functions: HashMap::new(),
              arrays: HashMap::new(),
              associative_array_names: HashSet::new(),
              #[cfg(unix)]
              coproc: None,
              command_executor: CommandExecutorWrapper(None),
 +            dir_stack: Vec::new(),
          };
          // Initialize with environment variables
              exported: HashMap::new(),
              local_scopes: Vec::new(),
              last_exit_status: 0,
 +            exit_requested: None,
              functions: HashMap::new(),
              arrays: HashMap::new(),
              associative_array_names: HashSet::new(),
              #[cfg(unix)]
              coproc: None,
              command_executor: CommandExecutorWrapper(None),
 +            dir_stack: Vec::new(),
+         }
+     }

crates/rush-interactive/Cargo.tomlmodified

  reedline = { workspace = true }
  nu-ansi-term = { workspace = true }
  crossterm = { workspace = true }
 +chrono = { workspace = true }
 +hostname = { workspace = true }
 +dirs = { workspace = true }
++
 +[target.'cfg(unix)'.dependencies]
 +nix = { workspace = true }

crates/rush-interactive/src/completer.rsmodified

 +use crate::completion_spec::{with_registry, CompletionSource};
  use reedline::{Completer, Span, Suggestion};
  use std::env;
  use std::fs;
  ///
  /// Provides context-aware completions:
  /// - Command names from PATH (when first word)
 +/// - Command-specific completions (from `complete` builtin)
  /// - File/directory names (for arguments)
  /// - Variable names (when typing $VAR)
  pub struct RushCompleter;
              "read", "shift", "wait", "kill", "times", "umask", "hash",
              "getopts", "exec", "command", "jobs", "fg", "bg",
              "coproc", "disown", "printf", "mapfile", "readarray",
 -            "break", "continue", "return", "source", ".",
 +            "break", "continue", "return", "source", ".", "complete",
 +            "pushd", "popd", "dirs",
          ];
          commands.extend(builtins.iter().map(|s| s.to_string()));
              .unwrap_or(0);
          (start, &line[start..pos])
+     }
++
 +    /// Parse the command line to get command name and argument position
 +    fn parse_command_line(line: &str, pos: usize) -> Option<(String, Vec<String>, usize)> {
 +        let before_cursor = &line[..pos];
 +        let words: Vec<&str> = before_cursor.split_whitespace().collect();
++
 +        if words.is_empty() {
 +            return None;
 +        }
++
 +        let command = words[0].to_string();
 +        let args: Vec<String> = words[1..].iter().map(|s| s.to_string()).collect();
 +        let arg_index = if args.is_empty() { 0 } else { args.len() - 1 };
++
 +        Some((command, args, arg_index))
 +    }
++
 +    /// Get command-specific completions from the registry
 +    fn get_command_completions(command: &str, partial: &str) -> Vec<(String, Option<String>)> {
 +        let mut completions = Vec::new();
++
 +        with_registry(|registry| {
 +            if let Some(specs) = registry.get(command) {
 +                for spec in specs {
 +                    // TODO: Check condition if specified
 +                    // For now, we'll skip condition checking
++
 +                    match &spec.source {
 +                        CompletionSource::Static(items) => {
 +                            for item in items {
 +                                if item.starts_with(partial) {
 +                                    completions.push((
 +                                        item.clone(),
 +                                        spec.description.clone(),
 +                                    ));
 +                                }
 +                            }
 +                        }
 +                        CompletionSource::Dynamic(cmd) => {
 +                            // Execute the command and use output lines as completions
 +                            if let Ok(output) = std::process::Command::new("sh")
 +                                .arg("-c")
 +                                .arg(cmd)
 +                                .output()
 +                            {
 +                                let stdout = String::from_utf8_lossy(&output.stdout);
 +                                for line in stdout.lines() {
 +                                    let trimmed = line.trim();
 +                                    if !trimmed.is_empty() && trimmed.starts_with(partial) {
 +                                        completions.push((
 +                                            trimmed.to_string(),
 +                                            spec.description.clone(),
 +                                        ));
 +                                    }
 +                                }
 +                            }
 +                        }
 +                        CompletionSource::ShortOption(c) => {
 +                            let opt = format!("-{}", c);
 +                            if opt.starts_with(partial) {
 +                                completions.push((opt, spec.description.clone()));
 +                            }
 +                        }
 +                        CompletionSource::LongOption(s) => {
 +                            let opt = format!("--{}", s);
 +                            if opt.starts_with(partial) {
 +                                completions.push((opt, spec.description.clone()));
 +                            }
 +                        }
 +                        CompletionSource::Option { short, long } => {
 +                            if let Some(c) = short {
 +                                let opt = format!("-{}", c);
 +                                if opt.starts_with(partial) {
 +                                    completions.push((opt, spec.description.clone()));
 +                                }
 +                            }
 +                            if let Some(l) = long {
 +                                let opt = format!("--{}", l);
 +                                if opt.starts_with(partial) {
 +                                    completions.push((opt, spec.description.clone()));
 +                                }
 +                            }
 +                        }
 +                    }
 +                }
 +            }
 +        });
++
 +        completions
 +    }
++
 +    /// Check if a command has file completion disabled
 +    fn has_no_files(command: &str) -> bool {
 +        with_registry(|registry| registry.has_no_files(command))
 +    }
+ }
  impl Default for RushCompleter {
+                 }
+             }
          } else {
 -            // Complete file/directory names
 -            // When partial is empty (e.g., "ls "), show all non-hidden files
 -            for file in Self::get_file_completions(partial) {
 -                suggestions.push(Suggestion {
 -                    value: file.clone(),
 -                    description: None,
 -                    style: None,
 -                    extra: None,
 -                    span,
 -                    append_whitespace: !file.ends_with('/'),
 -                });
 +            // Parse the command line to get the command being completed
 +            if let Some((command, _args, _arg_idx)) = Self::parse_command_line(line, pos) {
 +                // Get command-specific completions
 +                let cmd_completions = Self::get_command_completions(&command, partial);
++
 +                for (value, desc) in cmd_completions {
 +                    suggestions.push(Suggestion {
 +                        value,
 +                        description: desc,
 +                        style: None,
 +                        extra: None,
 +                        span,
 +                        append_whitespace: true,
 +                    });
 +                }
++
 +                // Add file completions unless disabled for this command
 +                if !Self::has_no_files(&command) {
 +                    for file in Self::get_file_completions(partial) {
 +                        suggestions.push(Suggestion {
 +                            value: file.clone(),
 +                            description: None,
 +                            style: None,
 +                            extra: None,
 +                            span,
 +                            append_whitespace: !file.ends_with('/'),
 +                        });
 +                    }
 +                }
 +            } else {
 +                // Fallback to file completions if we can't parse the command
 +                for file in Self::get_file_completions(partial) {
 +                    suggestions.push(Suggestion {
 +                        value: file.clone(),
 +                        description: None,
 +                        style: None,
 +                        extra: None,
 +                        span,
 +                        append_whitespace: !file.ends_with('/'),
 +                    });
 +                }
+             }
+         }
 +        // Remove duplicates (command completions might overlap with files)
 +        suggestions.sort_by(|a, b| a.value.cmp(&b.value));
 +        suggestions.dedup_by(|a, b| a.value == b.value);
++
          suggestions
+     }
+ }

crates/rush-interactive/src/completion_spec.rsadded

 +//! Command-specific completion specifications
 +//!
 +//! This module provides a fish-style completion system where users can define
 +//! custom completions for specific commands using the `complete` builtin.
 +//!
 +//! Example usage:
 +//! ```bash
 +//! # Add subcommand completions for git
 +//! complete -c git -a "add commit push pull fetch checkout branch"
 +//!
 +//! # Add dynamic branch completions for git checkout
 +//! complete -c git -n "__rush_seen_subcommand checkout" -a "(git branch --format='%(refname:short)')"
 +//!
 +//! # Add option completions
 +//! complete -c ls -s l -d "Long format"
 +//! complete -c ls -s a -l all -d "Show hidden files"
 +//!
 +//! # Disable file completion for a command
 +//! complete -c git -f
 +//! ```
++
 +use std::collections::HashMap;
 +use std::sync::RwLock;
++
 +/// Global registry of completion specifications
 +static COMPLETION_REGISTRY: RwLock<Option<CompletionRegistry>> = RwLock::new(None);
++
 +/// A single completion specification
 +#[derive(Debug, Clone)]
 +pub struct CompletionSpec {
 +    /// The command this completion applies to
 +    pub command: String,
++
 +    /// Condition that must be true for this completion to apply
 +    /// This is a shell expression that will be evaluated
 +    pub condition: Option<String>,
++
 +    /// The completions to provide
 +    pub source: CompletionSource,
++
 +    /// Description for these completions
 +    pub description: Option<String>,
++
 +    /// If true, don't also complete files
 +    pub no_files: bool,
 +}
++
 +/// Source of completion values
 +#[derive(Debug, Clone)]
 +pub enum CompletionSource {
 +    /// Static list of completion strings
 +    Static(Vec<String>),
++
 +    /// Dynamic command to run (output lines become completions)
 +    Dynamic(String),
++
 +    /// Short option (e.g., -v)
 +    ShortOption(char),
++
 +    /// Long option (e.g., --verbose)
 +    LongOption(String),
++
 +    /// Short and long option together (e.g., -v/--verbose)
 +    Option {
 +        short: Option<char>,
 +        long: Option<String>,
 +    },
 +}
++
 +/// Registry holding all completion specifications
 +#[derive(Debug, Default)]
 +pub struct CompletionRegistry {
 +    /// Completions indexed by command name
 +    specs: HashMap<String, Vec<CompletionSpec>>,
++
 +    /// Commands that should not have file completion
 +    no_file_commands: std::collections::HashSet<String>,
 +}
++
 +impl CompletionRegistry {
 +    pub fn new() -> Self {
 +        Self::default()
 +    }
++
 +    /// Add a completion specification
 +    pub fn add(&mut self, spec: CompletionSpec) {
 +        if spec.no_files {
 +            self.no_file_commands.insert(spec.command.clone());
 +        }
 +        self.specs
 +            .entry(spec.command.clone())
 +            .or_default()
 +            .push(spec);
 +    }
++
 +    /// Remove all completions for a command
 +    pub fn remove(&mut self, command: &str) {
 +        self.specs.remove(command);
 +        self.no_file_commands.remove(command);
 +    }
++
 +    /// Get completions for a command
 +    pub fn get(&self, command: &str) -> Option<&Vec<CompletionSpec>> {
 +        self.specs.get(command)
 +    }
++
 +    /// Check if a command has file completion disabled
 +    pub fn has_no_files(&self, command: &str) -> bool {
 +        self.no_file_commands.contains(command)
 +    }
++
 +    /// Get all registered commands
 +    pub fn commands(&self) -> Vec<&String> {
 +        self.specs.keys().collect()
 +    }
++
 +    /// Get all specs (for listing)
 +    pub fn all_specs(&self) -> &HashMap<String, Vec<CompletionSpec>> {
 +        &self.specs
 +    }
 +}
++
 +/// Initialize the global completion registry
 +pub fn init_registry() {
 +    let mut registry = COMPLETION_REGISTRY.write().unwrap();
 +    if registry.is_none() {
 +        let mut reg = CompletionRegistry::new();
 +        // Add default completions
 +        add_default_completions(&mut reg);
 +        *registry = Some(reg);
 +    }
 +}
++
 +/// Get a reference to the global registry for reading
 +pub fn with_registry<F, R>(f: F) -> R
 +where
 +    F: FnOnce(&CompletionRegistry) -> R,
 +{
 +    init_registry();
 +    let registry = COMPLETION_REGISTRY.read().unwrap();
 +    f(registry.as_ref().unwrap())
 +}
++
 +/// Get a mutable reference to the global registry
 +pub fn with_registry_mut<F, R>(f: F) -> R
 +where
 +    F: FnOnce(&mut CompletionRegistry) -> R,
 +{
 +    init_registry();
 +    let mut registry = COMPLETION_REGISTRY.write().unwrap();
 +    f(registry.as_mut().unwrap())
 +}
++
 +/// Add a completion spec to the global registry
 +pub fn add_completion(spec: CompletionSpec) {
 +    with_registry_mut(|reg| reg.add(spec));
 +}
++
 +/// Remove completions for a command from the global registry
 +pub fn remove_completions(command: &str) {
 +    with_registry_mut(|reg| reg.remove(command));
 +}
++
 +/// Add default completions for common commands
 +fn add_default_completions(registry: &mut CompletionRegistry) {
 +    // Git completions
 +    add_git_completions(registry);
++
 +    // Cargo completions
 +    add_cargo_completions(registry);
 +}
++
 +fn add_git_completions(registry: &mut CompletionRegistry) {
 +    // Git subcommands
 +    let git_subcommands = vec![
 +        "add", "bisect", "branch", "checkout", "clone", "commit", "diff",
 +        "fetch", "grep", "init", "log", "merge", "mv", "pull", "push",
 +        "rebase", "reset", "restore", "rm", "show", "stash", "status",
 +        "switch", "tag", "worktree",
 +    ];
++
 +    registry.add(CompletionSpec {
 +        command: "git".to_string(),
 +        condition: None,
 +        source: CompletionSource::Static(git_subcommands.into_iter().map(String::from).collect()),
 +        description: Some("Git subcommand".to_string()),
 +        no_files: false,
 +    });
++
 +    // Git branch completion for checkout/switch
 +    registry.add(CompletionSpec {
 +        command: "git".to_string(),
 +        condition: Some("__rush_git_needs_branch".to_string()),
 +        source: CompletionSource::Dynamic("git branch --format='%(refname:short)' 2>/dev/null".to_string()),
 +        description: Some("Branch name".to_string()),
 +        no_files: true,
 +    });
++
 +    // Common git options
 +    registry.add(CompletionSpec {
 +        command: "git".to_string(),
 +        condition: None,
 +        source: CompletionSource::Option {
 +            short: Some('v'),
 +            long: Some("verbose".to_string()),
 +        },
 +        description: Some("Be verbose".to_string()),
 +        no_files: false,
 +    });
++
 +    registry.add(CompletionSpec {
 +        command: "git".to_string(),
 +        condition: None,
 +        source: CompletionSource::Option {
 +            short: Some('h'),
 +            long: Some("help".to_string()),
 +        },
 +        description: Some("Show help".to_string()),
 +        no_files: false,
 +    });
 +}
++
 +fn add_cargo_completions(registry: &mut CompletionRegistry) {
 +    // Cargo subcommands
 +    let cargo_subcommands = vec![
 +        "build", "check", "clean", "doc", "new", "init", "add", "remove",
 +        "run", "test", "bench", "update", "search", "publish", "install",
 +        "uninstall", "fmt", "clippy", "fix", "tree", "vendor",
 +    ];
++
 +    registry.add(CompletionSpec {
 +        command: "cargo".to_string(),
 +        condition: None,
 +        source: CompletionSource::Static(cargo_subcommands.into_iter().map(String::from).collect()),
 +        description: Some("Cargo subcommand".to_string()),
 +        no_files: false,
 +    });
++
 +    // Common cargo options
 +    registry.add(CompletionSpec {
 +        command: "cargo".to_string(),
 +        condition: None,
 +        source: CompletionSource::Option {
 +            short: None,
 +            long: Some("release".to_string()),
 +        },
 +        description: Some("Build in release mode".to_string()),
 +        no_files: false,
 +    });
++
 +    registry.add(CompletionSpec {
 +        command: "cargo".to_string(),
 +        condition: None,
 +        source: CompletionSource::Option {
 +            short: None,
 +            long: Some("all-features".to_string()),
 +        },
 +        description: Some("Enable all features".to_string()),
 +        no_files: false,
 +    });
++
 +    registry.add(CompletionSpec {
 +        command: "cargo".to_string(),
 +        condition: None,
 +        source: CompletionSource::Option {
 +            short: Some('p'),
 +            long: Some("package".to_string()),
 +        },
 +        description: Some("Package to build".to_string()),
 +        no_files: false,
 +    });
++
 +    registry.add(CompletionSpec {
 +        command: "cargo".to_string(),
 +        condition: None,
 +        source: CompletionSource::Option {
 +            short: None,
 +            long: Some("bin".to_string()),
 +        },
 +        description: Some("Binary to run".to_string()),
 +        no_files: false,
 +    });
 +}
++
 +/// Helper struct for building completion specs fluently
 +pub struct CompletionBuilder {
 +    spec: CompletionSpec,
 +}
++
 +impl CompletionBuilder {
 +    pub fn new(command: &str) -> Self {
 +        Self {
 +            spec: CompletionSpec {
 +                command: command.to_string(),
 +                condition: None,
 +                source: CompletionSource::Static(vec![]),
 +                description: None,
 +                no_files: false,
 +            },
 +        }
 +    }
++
 +    pub fn condition(mut self, cond: &str) -> Self {
 +        self.spec.condition = Some(cond.to_string());
 +        self
 +    }
++
 +    pub fn completions(mut self, completions: Vec<String>) -> Self {
 +        self.spec.source = CompletionSource::Static(completions);
 +        self
 +    }
++
 +    pub fn dynamic(mut self, command: &str) -> Self {
 +        self.spec.source = CompletionSource::Dynamic(command.to_string());
 +        self
 +    }
++
 +    pub fn short_option(mut self, opt: char) -> Self {
 +        self.spec.source = CompletionSource::ShortOption(opt);
 +        self
 +    }
++
 +    pub fn long_option(mut self, opt: &str) -> Self {
 +        self.spec.source = CompletionSource::LongOption(opt.to_string());
 +        self
 +    }
++
 +    pub fn option(mut self, short: Option<char>, long: Option<&str>) -> Self {
 +        self.spec.source = CompletionSource::Option {
 +            short,
 +            long: long.map(String::from),
 +        };
 +        self
 +    }
++
 +    pub fn description(mut self, desc: &str) -> Self {
 +        self.spec.description = Some(desc.to_string());
 +        self
 +    }
++
 +    pub fn no_files(mut self) -> Self {
 +        self.spec.no_files = true;
 +        self
 +    }
++
 +    pub fn build(self) -> CompletionSpec {
 +        self.spec
 +    }
++
 +    pub fn register(self) {
 +        add_completion(self.build());
 +    }
 +}

crates/rush-interactive/src/highlighter.rsmodified

      fn is_builtin(command: &str) -> bool {
          matches!(
              command,
 -            "cd" | "pwd" | "exit" | "jobs" | "fg" | "bg" | "test" | "["
 +            "cd" | "pwd" | "exit" | "true" | "false" | "test" | "[" | ":"
 +                | "eval" | "alias" | "unalias" | "trap" | "set" | "shopt"
 +                | "export" | "unset" | "readonly" | "declare" | "typeset" | "local"
 +                | "read" | "shift" | "wait" | "kill" | "times" | "umask" | "hash"
 +                | "getopts" | "exec" | "command" | "jobs" | "fg" | "bg"
 +                | "coproc" | "disown" | "printf" | "mapfile" | "readarray"
 +                | "break" | "continue" | "return" | "source" | "."
 +                | "complete" | "pushd" | "popd" | "dirs"
+         )
+     }

crates/rush-interactive/src/lib.rsmodified

  // Rush interactive - Fish-like interactive features
  pub mod completer;
 +pub mod completion_spec;
  pub mod error_hints;
  pub mod highlighter;
  pub mod hinter;
 +pub mod prompt;
  pub use completer::RushCompleter;
 +pub use completion_spec::{
 +    add_completion, remove_completions, with_registry, with_registry_mut,
 +    CompletionBuilder, CompletionRegistry, CompletionSource, CompletionSpec,
 +};
  pub use error_hints::ErrorHints;
  pub use highlighter::RushHighlighter;
  pub use hinter::RushHinter;
 +pub use prompt::RushPrompt;

crates/rush-interactive/src/prompt.rsadded

 +//! Custom shell prompt with PS1 support
 +//!
 +//! Implements bash-compatible prompt escape sequences:
 +//! - `\u` - Username
 +//! - `\h` - Hostname (short)
 +//! - `\H` - Hostname (full)
 +//! - `\w` - Working directory (~ for home)
 +//! - `\W` - Basename of working directory
 +//! - `\$` - `#` if root, `$` otherwise
 +//! - `\n` - Newline
 +//! - `\r` - Carriage return
 +//! - `\t` - Current time 24-hour (HH:MM:SS)
 +//! - `\T` - Current time 12-hour (HH:MM:SS)
 +//! - `\@` - Current time 12-hour with AM/PM (HH:MM AM/PM)
 +//! - `\A` - Current time 24-hour (HH:MM)
 +//! - `\d` - Date (Day Mon Date)
 +//! - `\D{format}` - Custom strftime format (e.g., `\D{%Y-%m-%d}`)
 +//! - `\\` - Literal backslash
++
 +use reedline::Prompt;
 +use std::borrow::Cow;
 +use std::env;
++
 +/// Custom prompt that supports PS1-style escape sequences
 +pub struct RushPrompt {
 +    /// Cached username
 +    username: String,
 +    /// Cached hostname (short)
 +    hostname_short: String,
 +    /// Cached hostname (full)
 +    hostname_full: String,
 +    /// Cached home directory
 +    home_dir: Option<String>,
 +}
++
 +impl RushPrompt {
 +    pub fn new() -> Self {
 +        let username = env::var("USER")
 +            .or_else(|_| env::var("USERNAME"))
 +            .unwrap_or_else(|_| "user".to_string());
++
 +        let hostname_full = hostname::get()
 +            .map(|h| h.to_string_lossy().to_string())
 +            .unwrap_or_else(|_| "localhost".to_string());
++
 +        let hostname_short = hostname_full
 +            .split('.')
 +            .next()
 +            .unwrap_or("localhost")
 +            .to_string();
++
 +        let home_dir = dirs::home_dir().map(|p| p.to_string_lossy().to_string());
++
 +        Self {
 +            username,
 +            hostname_short,
 +            hostname_full,
 +            home_dir,
 +        }
 +    }
++
 +    /// Expand PS1-style escape sequences
 +    pub fn expand_ps1(&self, ps1: &str) -> String {
 +        let mut result = String::with_capacity(ps1.len() * 2);
 +        let mut chars = ps1.chars().peekable();
++
 +        while let Some(ch) = chars.next() {
 +            if ch == '\\' {
 +                if let Some(&next) = chars.peek() {
 +                    chars.next();
 +                    match next {
 +                        'u' => result.push_str(&self.username),
 +                        'h' => result.push_str(&self.hostname_short),
 +                        'H' => result.push_str(&self.hostname_full),
 +                        'w' => result.push_str(&self.get_working_dir(false)),
 +                        'W' => result.push_str(&self.get_working_dir(true)),
 +                        '$' => {
 +                            // # for root, $ otherwise
 +                            if self.is_root() {
 +                                result.push('#');
 +                            } else {
 +                                result.push('$');
 +                            }
 +                        }
 +                        'n' => result.push('\n'),
 +                        'r' => result.push('\r'),
 +                        't' => result.push_str(&self.get_time_24()),      // HH:MM:SS (24-hour)
 +                        'T' => result.push_str(&self.get_time_12()),      // HH:MM:SS (12-hour)
 +                        '@' => result.push_str(&self.get_time_12_ampm()), // HH:MM AM/PM
 +                        'A' => result.push_str(&self.get_time_24_short()), // HH:MM (24-hour)
 +                        'd' => result.push_str(&self.get_date()),
 +                        'D' => {
 +                            // Custom date format: \D{format}
 +                            if chars.peek() == Some(&'{') {
 +                                chars.next(); // consume '{'
 +                                let mut format = String::new();
 +                                while let Some(&c) = chars.peek() {
 +                                    chars.next();
 +                                    if c == '}' {
 +                                        break;
 +                                    }
 +                                    format.push(c);
 +                                }
 +                                result.push_str(&self.get_custom_datetime(&format));
 +                            } else {
 +                                // No format specified, use default
 +                                result.push_str(&self.get_date());
 +                            }
 +                        }
 +                        '\\' => result.push('\\'),
 +                        '[' => {} // Start of non-printing sequence (ignored for now)
 +                        ']' => {} // End of non-printing sequence (ignored for now)
 +                        _ => {
 +                            // Unknown escape, keep as-is
 +                            result.push('\\');
 +                            result.push(next);
 +                        }
 +                    }
 +                } else {
 +                    result.push('\\');
 +                }
 +            } else {
 +                result.push(ch);
 +            }
 +        }
++
 +        result
 +    }
++
 +    /// Get the current working directory, optionally just the basename
 +    fn get_working_dir(&self, basename_only: bool) -> String {
 +        let cwd = env::current_dir()
 +            .map(|p| p.to_string_lossy().to_string())
 +            .unwrap_or_else(|_| "?".to_string());
++
 +        if basename_only {
 +            std::path::Path::new(&cwd)
 +                .file_name()
 +                .map(|n| n.to_string_lossy().to_string())
 +                .unwrap_or_else(|| cwd.clone())
 +        } else {
 +            // Replace home directory with ~
 +            if let Some(home) = &self.home_dir {
 +                if cwd == *home {
 +                    "~".to_string()
 +                } else if cwd.starts_with(home) {
 +                    format!("~{}", &cwd[home.len()..])
 +                } else {
 +                    cwd
 +                }
 +            } else {
 +                cwd
 +            }
 +        }
 +    }
++
 +    /// Check if the current user is root
 +    fn is_root(&self) -> bool {
 +        #[cfg(unix)]
 +        {
 +            nix::unistd::getuid().is_root()
 +        }
 +        #[cfg(not(unix))]
 +        {
 +            false
 +        }
 +    }
++
 +    /// Get current time in HH:MM:SS 24-hour format (\t)
 +    fn get_time_24(&self) -> String {
 +        chrono::Local::now().format("%H:%M:%S").to_string()
 +    }
++
 +    /// Get current time in HH:MM:SS 12-hour format (\T)
 +    fn get_time_12(&self) -> String {
 +        chrono::Local::now().format("%I:%M:%S").to_string()
 +    }
++
 +    /// Get current time in HH:MM AM/PM format (\@)
 +    fn get_time_12_ampm(&self) -> String {
 +        chrono::Local::now().format("%I:%M %p").to_string()
 +    }
++
 +    /// Get current time in HH:MM 24-hour format (\A)
 +    fn get_time_24_short(&self) -> String {
 +        chrono::Local::now().format("%H:%M").to_string()
 +    }
++
 +    /// Get current date in "Day Mon Date" format (\d)
 +    fn get_date(&self) -> String {
 +        chrono::Local::now().format("%a %b %d").to_string()
 +    }
++
 +    /// Get custom datetime format (\D{format})
 +    fn get_custom_datetime(&self, format: &str) -> String {
 +        chrono::Local::now().format(format).to_string()
 +    }
 +}
++
 +impl Default for RushPrompt {
 +    fn default() -> Self {
 +        Self::new()
 +    }
 +}
++
 +impl Prompt for RushPrompt {
 +    fn render_prompt_left(&self) -> Cow<'_, str> {
 +        // Check for PS1 environment variable
 +        if let Ok(ps1) = env::var("PS1") {
 +            Cow::Owned(self.expand_ps1(&ps1))
 +        } else {
 +            // Default prompt: path〉 (fish-style)
 +            Cow::Owned(format!("{}〉", self.get_working_dir(false)))
 +        }
 +    }
++
 +    fn render_prompt_right(&self) -> Cow<'_, str> {
 +        // Check for PS1_RIGHT environment variable (custom extension)
 +        if let Ok(ps1_right) = env::var("PS1_RIGHT") {
 +            Cow::Owned(self.expand_ps1(&ps1_right))
 +        } else {
 +            // Default right prompt: date and time
 +            Cow::Owned(chrono::Local::now().format("%m/%d/%Y %I:%M:%S %p").to_string())
 +        }
 +    }
++
 +    fn render_prompt_indicator(&self, _edit_mode: reedline::PromptEditMode) -> Cow<'_, str> {
 +        Cow::Borrowed("")
 +    }
++
 +    fn render_prompt_multiline_indicator(&self) -> Cow<'_, str> {
 +        Cow::Borrowed("> ")
 +    }
++
 +    fn render_prompt_history_search_indicator(
 +        &self,
 +        _history_search: reedline::PromptHistorySearch,
 +    ) -> Cow<'_, str> {
 +        Cow::Borrowed("(search) ")
 +    }
++
 +    fn get_prompt_color(&self) -> reedline::Color {
 +        reedline::Color::Reset
 +    }
++
 +    fn get_prompt_multiline_color(&self) -> nu_ansi_term::Color {
 +        nu_ansi_term::Color::LightGray
 +    }
++
 +    fn get_indicator_color(&self) -> reedline::Color {
 +        reedline::Color::Reset
 +    }
++
 +    fn get_prompt_right_color(&self) -> reedline::Color {
 +        reedline::Color::Reset
 +    }
 +}

crates/rush-job/src/job.rsmodified

              self.remove_job(id);
+         }
+     }
++
 +    /// Send SIGHUP to all running jobs
 +    /// Called when the shell is exiting to notify background jobs
 +    pub fn send_hup_to_all(&self) {
 +        use nix::sys::signal::{killpg, Signal};
++
 +        for job in self.jobs.values() {
 +            if job.is_running() || job.is_stopped() {
 +                // Send SIGHUP to the process group
 +                let _ = killpg(job.pgid, Signal::SIGHUP);
 +                // Also send SIGCONT in case the job was stopped
 +                if job.is_stopped() {
 +                    let _ = killpg(job.pgid, Signal::SIGCONT);
 +                }
 +            }
 +        }
 +    }
++
 +    /// Check if there are any running or stopped jobs
 +    pub fn has_active_jobs(&self) -> bool {
 +        self.jobs.values().any(|job| job.is_running() || job.is_stopped())
 +    }
+ }
  #[cfg(test)]

crates/rush-job/src/lib.rsmodified

  pub mod terminal;
  pub use job::{Job, JobId, JobList, JobState};
 -pub use signals::{check_children, setup_job_control_signals};
 -pub use terminal::{give_terminal_to, restore_shell_terminal, setup_shell_terminal};
 +pub use signals::{check_children, check_sighup, check_sigwinch, setup_job_control_signals};
 +pub use terminal::{
 +    give_terminal_to, get_terminal_attrs, restore_shell_terminal, restore_terminal_attrs,
 +    save_terminal_attrs, set_terminal_attrs, setup_shell_terminal,
 +};
  use thiserror::Error;

crates/rush-job/src/signals.rsmodified

  use nix::sys::signal::{signal, SigHandler, Signal};
  use nix::sys::wait::{waitpid, WaitPidFlag, WaitStatus};
  use nix::unistd::Pid;
 +use std::sync::atomic::{AtomicBool, Ordering};
++
 +/// Flag indicating SIGWINCH was received (terminal resized)
 +pub static SIGWINCH_RECEIVED: AtomicBool = AtomicBool::new(false);
++
 +/// Flag indicating SIGHUP was received (terminal closed)
 +pub static SIGHUP_RECEIVED: AtomicBool = AtomicBool::new(false);
++
 +/// SIGWINCH handler - sets flag for main loop to check
 +extern "C" fn handle_sigwinch(_: i32) {
 +    SIGWINCH_RECEIVED.store(true, Ordering::SeqCst);
 +}
++
 +/// SIGHUP handler - sets flag for main loop to check
 +extern "C" fn handle_sighup(_: i32) {
 +    SIGHUP_RECEIVED.store(true, Ordering::SeqCst);
 +}
  /// Setup job control signal handlers
  ///
  /// - SIGCHLD: Reap completed/stopped child processes
  /// - SIGINT: Interrupt (Ctrl-C) - handled by foreground job
  /// - SIGTSTP: Suspend (Ctrl-Z) - handled by foreground job
 +/// - SIGWINCH: Terminal resize - flagged for notification
 +/// - SIGHUP: Terminal hangup - flagged for cleanup
 +/// - SIGQUIT: Quit (Ctrl-\) - ignored by shell
  ///
  /// Note: The actual signal handling is done via polling in the main loop,
  /// not via signal handlers (to avoid async-signal-safety issues).
  pub fn setup_job_control_signals() -> Result<(), nix::Error> {
 -    // Set SIGCHLD to default (we'll poll for child status changes)
      unsafe {
 +        // Set SIGCHLD to default (we'll poll for child status changes)
          signal(Signal::SIGCHLD, SigHandler::SigDfl)?;
++
 +        // SIGWINCH: Handle terminal resize
 +        signal(Signal::SIGWINCH, SigHandler::Handler(handle_sigwinch))?;
++
 +        // SIGHUP: Handle terminal hangup (e.g., closing terminal window)
 +        signal(Signal::SIGHUP, SigHandler::Handler(handle_sighup))?;
++
 +        // SIGQUIT (Ctrl-\): Ignore in shell, let foreground job handle it
 +        signal(Signal::SIGQUIT, SigHandler::SigIgn)?;
+     }
      // SIGINT and SIGTSTP are handled by the foreground job
      Ok(())
+ }
 +/// Check if terminal was resized
 +pub fn check_sigwinch() -> bool {
 +    SIGWINCH_RECEIVED.swap(false, Ordering::SeqCst)
 +}
++
 +/// Check if SIGHUP was received
 +pub fn check_sighup() -> bool {
 +    SIGHUP_RECEIVED.swap(false, Ordering::SeqCst)
 +}
++
  /// Check for completed or stopped child processes
  ///
  /// This should be called periodically (e.g., before displaying a prompt)

crates/rush-job/src/terminal.rsmodified

 +use nix::sys::termios::{tcgetattr, tcsetattr, SetArg, Termios};
  use nix::unistd::{tcgetpgrp, tcsetpgrp, Pid};
  use std::io;
 +use std::os::fd::AsFd;
 +use std::sync::Mutex;
++
 +/// Saved terminal attributes for restoration
 +static SAVED_TERMIOS: Mutex<Option<Termios>> = Mutex::new(None);
  /// Give terminal control to a process group
  ///
      tcsetpgrp(&stdin, pgid)
+ }
 +/// Save current terminal attributes
 +/// Call this at shell startup to preserve the initial terminal state
 +pub fn save_terminal_attrs() -> Result<(), nix::Error> {
 +    let stdin = io::stdin();
 +    let termios = tcgetattr(stdin.as_fd())?;
 +    let mut saved = SAVED_TERMIOS.lock().unwrap();
 +    *saved = Some(termios);
 +    Ok(())
 +}
++
 +/// Restore saved terminal attributes
 +/// Call this when the shell exits or after a child misbehaves
 +pub fn restore_terminal_attrs() -> Result<(), nix::Error> {
 +    let saved = SAVED_TERMIOS.lock().unwrap();
 +    if let Some(ref termios) = *saved {
 +        let stdin = io::stdin();
 +        tcsetattr(stdin.as_fd(), SetArg::TCSADRAIN, termios)?;
 +    }
 +    Ok(())
 +}
++
 +/// Get current terminal attributes
 +pub fn get_terminal_attrs() -> Result<Termios, nix::Error> {
 +    let stdin = io::stdin();
 +    tcgetattr(stdin.as_fd())
 +}
++
 +/// Set terminal attributes
 +pub fn set_terminal_attrs(termios: &Termios) -> Result<(), nix::Error> {
 +    let stdin = io::stdin();
 +    tcsetattr(stdin.as_fd(), SetArg::TCSADRAIN, termios)
 +}
++
  /// Get the current foreground process group of the terminal
  pub fn get_terminal_pgid() -> Result<Pid, nix::Error> {
      let stdin = io::stdin();