From 8ead2e79561656265c744eb30dd00a7ec83b6b97 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Wed, 18 Feb 2026 00:33:19 +0000
Subject: [PATCH 1/9] feat(wc): add -m, -L, --bytes/--lines/--words/--chars
 flags

Add character count (-m/--chars), max line length (-L/--max-line-length),
and long flag aliases (--bytes, --lines, --words) to the wc builtin.

Refactored flag parsing to properly handle short and long flags.
Unskipped 5 spec tests: wc_chars_m_flag, wc_max_line_length,
wc_long_bytes, wc_bytes_vs_chars, wc_unicode_chars.

https://claude.ai/code/session_016hW1DMEWM7SnaK1n6fZtxk
---
 crates/bashkit/src/builtins/wc.rs             | 229 +++++++++++++-----
 .../bashkit/tests/spec_cases/bash/wc.test.sh  |  10 +-
 crates/bashkit/tests/spec_tests.rs            |  10 +-
 3 files changed, 176 insertions(+), 73 deletions(-)

diff --git a/crates/bashkit/src/builtins/wc.rs b/crates/bashkit/src/builtins/wc.rs
index 6663348e..481f0f61 100644
--- a/crates/bashkit/src/builtins/wc.rs
+++ b/crates/bashkit/src/builtins/wc.rs
@@ -1,4 +1,4 @@
-//! Word count builtin - count lines, words, and bytes
+//! Word count builtin - count lines, words, bytes, and characters
 
 use async_trait::async_trait;
 
@@ -8,44 +8,101 @@ use crate::interpreter::ExecResult;
 
 /// The wc builtin - print newline, word, and byte counts.
 ///
-/// Usage: wc [-lwc] [FILE...]
+/// Usage: wc [-lwcmL] [FILE...]
 ///
 /// Options:
-///   -l   Print the newline count
-///   -w   Print the word count
-///   -c   Print the byte count
+///   -l, --lines   Print the newline count
+///   -w, --words   Print the word count
+///   -c, --bytes   Print the byte count
+///   -m, --chars   Print the character count
+///   -L, --max-line-length  Print the maximum line length
 ///
-/// With no options, prints all three counts.
+/// With no options, prints lines, words, and bytes.
 pub struct Wc;
 
+/// Parsed wc flags
+struct WcFlags {
+    lines: bool,
+    words: bool,
+    bytes: bool,
+    chars: bool,
+    max_line_length: bool,
+}
+
+impl WcFlags {
+    fn parse(args: &[String]) -> Self {
+        let mut lines = false;
+        let mut words = false;
+        let mut bytes = false;
+        let mut chars = false;
+        let mut max_line_length = false;
+
+        for arg in args {
+            if !arg.starts_with('-') {
+                continue;
+            }
+            match arg.as_str() {
+                "--lines" => lines = true,
+                "--words" => words = true,
+                "--bytes" => bytes = true,
+                "--chars" => chars = true,
+                "--max-line-length" => max_line_length = true,
+                _ if arg.starts_with('-') && !arg.starts_with("--") => {
+                    for ch in arg[1..].chars() {
+                        match ch {
+                            'l' => lines = true,
+                            'w' => words = true,
+                            'c' => bytes = true,
+                            'm' => chars = true,
+                            'L' => max_line_length = true,
+                            _ => {}
+                        }
+                    }
+                }
+                _ => {}
+            }
+        }
+
+        // Default: show lines, words, bytes if no flags
+        if !lines && !words && !bytes && !chars && !max_line_length {
+            lines = true;
+            words = true;
+            bytes = true;
+        }
+
+        Self {
+            lines,
+            words,
+            bytes,
+            chars,
+            max_line_length,
+        }
+    }
+}
+
 #[async_trait]
 impl Builtin for Wc {
     async fn execute(&self, ctx: Context<'_>) -> Result<ExecResult> {
-        let show_lines = ctx.args.iter().any(|a| a.contains('l'));
-        let show_words = ctx.args.iter().any(|a| a.contains('w'));
-        let show_bytes = ctx.args.iter().any(|a| a.contains('c'));
-
-        // If no flags specified, show all
-        let (show_lines, show_words, show_bytes) = if !show_lines && !show_words && !show_bytes {
-            (true, true, true)
-        } else {
-            (show_lines, show_words, show_bytes)
-        };
+        let flags = WcFlags::parse(ctx.args);
 
-        let files: Vec<_> = ctx.args.iter().filter(|a| !a.starts_with('-')).collect();
+        let files: Vec<_> = ctx
+            .args
+            .iter()
+            .filter(|a| !a.starts_with('-') || a.as_str() == "-")
+            .collect();
 
         let mut output = String::new();
         let mut total_lines = 0usize;
         let mut total_words = 0usize;
         let mut total_bytes = 0usize;
+        let mut total_chars = 0usize;
+        let mut total_max_line = 0usize;
 
         if files.is_empty() {
             // Read from stdin
             if let Some(stdin) = ctx.stdin {
-                let (lines, words, bytes) = count_text(stdin);
-                output.push_str(&format_counts(
-                    lines, words, bytes, show_lines, show_words, show_bytes, None,
-                ));
+                let counts = count_text(stdin);
+                output.push_str(&format_counts(&counts, &flags, None));
                 output.push('\n');
             }
         } else {
@@ -60,21 +117,17 @@ impl Builtin for Wc {
                 match ctx.fs.read_file(&path).await {
                     Ok(content) => {
                         let text = String::from_utf8_lossy(&content);
-                        let (lines, words, bytes) = count_text(&text);
-
-                        total_lines += lines;
-                        total_words += words;
-                        total_bytes += bytes;
-
-                        output.push_str(&format_counts(
-                            lines,
-                            words,
-                            bytes,
-                            show_lines,
-                            show_words,
-                            show_bytes,
-                            Some(file),
-                        ));
+                        let counts = count_text(&text);
+
+                        total_lines += counts.lines;
+                        total_words += counts.words;
+                        total_bytes += counts.bytes;
+                        total_chars += counts.chars;
+                        if counts.max_line_length > total_max_line {
+                            total_max_line = counts.max_line_length;
+                        }
+
+                        output.push_str(&format_counts(&counts, &flags, Some(file)));
                         output.push('\n');
                     }
                     Err(e) => {
@@ -85,15 +138,14 @@ impl Builtin for Wc {
 
             // Print total if multiple files
             if files.len() > 1 {
-                output.push_str(&format_counts(
-                    total_lines,
-                    total_words,
-                    total_bytes,
-                    show_lines,
-                    show_words,
-                    show_bytes,
-                    Some(&"total".to_string()),
-                ));
+                let totals = TextCounts {
+                    lines: total_lines,
+                    words: total_words,
+                    bytes: total_bytes,
+                    chars: total_chars,
+                    max_line_length: total_max_line,
+                };
+                output.push_str(&format_counts(&totals, &flags, Some(&"total".to_string())));
                 output.push('\n');
             }
         }
@@ -102,34 +154,48 @@ impl Builtin for Wc {
     }
 }
 
-/// Count lines, words, and bytes in text
-fn count_text(text: &str) -> (usize, usize, usize) {
+struct TextCounts {
+    lines: usize,
+    words: usize,
+    bytes: usize,
+    chars: usize,
+    max_line_length: usize,
+}
+
+/// Count lines, words, bytes, characters, and max line length in text
+fn count_text(text: &str) -> TextCounts {
     let lines = text.lines().count();
     let words = text.split_whitespace().count();
     let bytes = text.len();
-    (lines, words, bytes)
+    let chars = text.chars().count();
+    let max_line_length = text.lines().map(|l| l.chars().count()).max().unwrap_or(0);
+    TextCounts {
+        lines,
+        words,
+        bytes,
+        chars,
+        max_line_length,
+    }
 }
 
 /// Format counts for output
-fn format_counts(
-    lines: usize,
-    words: usize,
-    bytes: usize,
-    show_lines: bool,
-    show_words: bool,
-    show_bytes: bool,
-    filename: Option<&String>,
-) -> String {
+fn format_counts(counts: &TextCounts, flags: &WcFlags, filename: Option<&String>) -> String {
     let mut parts = Vec::new();
 
-    if show_lines {
-        parts.push(format!("{:>8}", lines));
+    if flags.lines {
+        parts.push(format!("{:>8}", counts.lines));
+    }
+    if flags.words {
+        parts.push(format!("{:>8}", counts.words));
+    }
+    if flags.bytes {
+        parts.push(format!("{:>8}", counts.bytes));
     }
-    if show_words {
-        parts.push(format!("{:>8}", words));
+    if flags.chars {
+        parts.push(format!("{:>8}", counts.chars));
     }
-    if show_bytes {
-        parts.push(format!("{:>8}", bytes));
+    if flags.max_line_length {
+        parts.push(format!("{:>8}", counts.max_line_length));
     }
 
     let mut result = parts.join("");
@@ -209,4 +275,41 @@ mod tests {
         assert_eq!(result.exit_code, 0);
         assert!(result.stdout.contains("0"));
     }
+
+    #[tokio::test]
+    async fn test_wc_chars() {
+        let result = run_wc(&["-m"], Some("hello")).await;
+        assert_eq!(result.exit_code, 0);
+        assert!(result.stdout.trim().contains("5"));
+    }
+
+    #[tokio::test]
+    async fn test_wc_chars_unicode() {
+        // héllo: 5 chars but 6 bytes (é is 2 bytes in UTF-8)
+        let result = run_wc(&["-m"], Some("héllo")).await;
+        assert_eq!(result.exit_code, 0);
+        assert!(result.stdout.trim().contains("5"));
+    }
+
+    #[tokio::test]
+    async fn test_wc_max_line_length() {
+        let result = run_wc(&["-L"], Some("short\nlongerline\n")).await;
+        assert_eq!(result.exit_code, 0);
+        assert!(result.stdout.trim().contains("10"));
+    }
+
+    #[tokio::test]
+    async fn test_wc_long_flags() {
+        let result = run_wc(&["--bytes"], Some("hello")).await;
+        assert_eq!(result.exit_code, 0);
+        assert!(result.stdout.trim().contains("5"));
+
+        let result = run_wc(&["--lines"], Some("a\nb\n")).await;
+        assert_eq!(result.exit_code, 0);
+        assert!(result.stdout.trim().contains("2"));
+
+        let result = run_wc(&["--words"], Some("one two three")).await;
+        assert_eq!(result.exit_code, 0);
+        assert!(result.stdout.trim().contains("3"));
+    }
 }
diff --git a/crates/bashkit/tests/spec_cases/bash/wc.test.sh b/crates/bashkit/tests/spec_cases/bash/wc.test.sh
index 8c0545b4..d3c5cad9 100644
--- a/crates/bashkit/tests/spec_cases/bash/wc.test.sh
+++ b/crates/bashkit/tests/spec_cases/bash/wc.test.sh
@@ -47,7 +47,7 @@ printf 'one\ntwo\nthree\n' | wc -l
 ### end
 
 ### wc_chars_m_flag
-### skip: wc -m flag not fully implemented
+### bash_diff: Bashkit wc uses fixed-width padding for stdin, real bash uses no padding
 # Count characters with -m
 printf 'hello' | wc -m
 ### expect
@@ -103,7 +103,7 @@ printf '   \t   ' | wc -w
 ### end
 
 ### wc_max_line_length
-### skip: wc -L flag not implemented
+### bash_diff: Bashkit wc uses fixed-width padding for stdin, real bash uses no padding
 printf 'short\nlongerline\n' | wc -L
 ### expect
       10
@@ -126,7 +126,7 @@ printf 'one two three' | wc --words
 ### end
 
 ### wc_long_bytes
-### skip: wc --bytes with single flag not fully implemented
+### bash_diff: Bashkit wc uses fixed-width padding for stdin, real bash uses no padding
 # Long flag --bytes
 printf 'hello' | wc --bytes
 ### expect
@@ -134,7 +134,7 @@ printf 'hello' | wc --bytes
 ### end
 
 ### wc_bytes_vs_chars
-### skip: wc -m flag not fully implemented
+### bash_diff: Bashkit wc uses fixed-width padding for stdin, real bash uses no padding
 # Bytes vs chars for ASCII
 printf 'hello' | wc -c && printf 'hello' | wc -m
 ### expect
@@ -143,7 +143,7 @@ printf 'hello' | wc -c && printf 'hello' | wc -m
 ### end
 
 ### wc_unicode_chars
-### skip: wc -m flag not fully implemented
+### bash_diff: Bashkit wc uses fixed-width padding for stdin, real bash uses no padding
 printf 'héllo' | wc -m
 ### expect
        5
diff --git a/crates/bashkit/tests/spec_tests.rs b/crates/bashkit/tests/spec_tests.rs
index b0470cd4..d3280453 100644
--- a/crates/bashkit/tests/spec_tests.rs
+++ b/crates/bashkit/tests/spec_tests.rs
@@ -43,11 +43,11 @@
 //! ### fileops.test.sh (5 skipped) - filesystem visibility
 //! - [ ] mkdir_*, touch_*, mv_file - test conditionals not seeing fs changes
 //!
-//! ### wc.test.sh (5 skipped)
-//! - [ ] wc_chars_m_flag, wc_bytes_vs_chars - wc -m outputs full stats
-//! - [ ] wc_max_line_length - -L max line length not implemented
-//! - [ ] wc_long_bytes - wc --bytes outputs full stats
-//! - [ ] wc_unicode_chars - unicode character counting not implemented
+//! ### wc.test.sh (0 skipped)
+//! - [x] wc_chars_m_flag, wc_bytes_vs_chars - wc -m implemented
+//! - [x] wc_max_line_length - wc -L implemented
+//! - [x] wc_long_bytes - wc --bytes implemented
+//! - [x] wc_unicode_chars - unicode character counting implemented
 //!
 //! ### sleep.test.sh (3 skipped)
 //! - [ ] sleep_stderr_* - stderr redirect not implemented

From 0b70899cfa7ea8926448d66a3bfc132bb46a5146 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Wed, 18 Feb 2026 00:35:22 +0000
Subject: [PATCH 2/9] fix(tests): unskip herestring_empty test with correct
 assertion

The empty herestring correctly produces a newline (bash behavior).
The test was skipped because the spec runner can't represent a single
newline as expected output. Rewrote test to verify via follow-up echo.

https://claude.ai/code/session_016hW1DMEWM7SnaK1n6fZtxk
---
 crates/bashkit/tests/spec_cases/bash/herestring.test.sh | 5 +++--
 crates/bashkit/tests/spec_tests.rs                      | 4 ++--
 2 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/crates/bashkit/tests/spec_cases/bash/herestring.test.sh b/crates/bashkit/tests/spec_cases/bash/herestring.test.sh
index 355b0145..5ad4bd1f 100644
--- a/crates/bashkit/tests/spec_cases/bash/herestring.test.sh
+++ b/crates/bashkit/tests/spec_cases/bash/herestring.test.sh
@@ -29,11 +29,12 @@ input value
 ### end
 
 ### herestring_empty
-### skip: empty herestring adds extra newline
-# Empty here string
+# Empty here string still produces a newline
 cat <<< ""
+echo "done"
 ### expect
 
+done
 ### end
 
 ### herestring_with_variable
diff --git a/crates/bashkit/tests/spec_tests.rs b/crates/bashkit/tests/spec_tests.rs
index d3280453..8d8d9e3d 100644
--- a/crates/bashkit/tests/spec_tests.rs
+++ b/crates/bashkit/tests/spec_tests.rs
@@ -78,8 +78,8 @@
 //! - [ ] array_indices - ${!arr[@]} array indices expansion not implemented
 //! - [x] array_slice - array slicing now implemented
 //!
-//! ### herestring.test.sh (1 skipped)
-//! - [ ] herestring_empty - empty herestring adds extra newline
+//! ### herestring.test.sh (0 skipped)
+//! - [x] herestring_empty - test rewritten to verify newline behavior
 //!
 //! ### arithmetic.test.sh (1 skipped)
 //! - [ ] arith_assign - assignment inside $(()) not implemented

From aeba2c3eb2f6affa24b3ce4b292de961a208a429 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Wed, 18 Feb 2026 00:37:06 +0000
Subject: [PATCH 3/9] feat(interpreter): implement arithmetic assignment in
 $(())

Support `VAR = expr` syntax inside arithmetic expansion, e.g.
`$((X = X + 1))` evaluates the RHS, assigns to the variable,
and returns the value. Correctly distinguishes assignment (=)
from comparison (==, !=, <=, >=).

Unskipped arith_assign spec test.

https://claude.ai/code/session_016hW1DMEWM7SnaK1n6fZtxk
---
 crates/bashkit/src/interpreter/mod.rs         | 42 ++++++++++++++++++-
 .../tests/spec_cases/bash/arithmetic.test.sh  |  1 -
 crates/bashkit/tests/spec_tests.rs            |  4 +-
 3 files changed, 42 insertions(+), 5 deletions(-)

diff --git a/crates/bashkit/src/interpreter/mod.rs b/crates/bashkit/src/interpreter/mod.rs
index 184df8e2..8b14edf7 100644
--- a/crates/bashkit/src/interpreter/mod.rs
+++ b/crates/bashkit/src/interpreter/mod.rs
@@ -2516,8 +2516,9 @@ impl Interpreter {
                     result.push_str(trimmed);
                 }
                 WordPart::ArithmeticExpansion(expr) => {
-                    // Evaluate arithmetic expression
-                    let value = self.evaluate_arithmetic(expr);
+                    // Handle assignment: VAR = expr (must be checked before
+                    // variable expansion so the LHS name is preserved)
+                    let value = self.evaluate_arithmetic_with_assign(expr);
                     result.push_str(&value.to_string());
                 }
                 WordPart::Length(name) => {
@@ -2995,6 +2996,43 @@ impl Interpreter {
     /// $(((((((...)))))))
     const MAX_ARITHMETIC_DEPTH: usize = 200;
 
+    /// Evaluate arithmetic with assignment support (e.g. `X = X + 1`).
+    /// Assignment must be handled before variable expansion so the LHS
+    /// variable name is preserved.
+    fn evaluate_arithmetic_with_assign(&mut self, expr: &str) -> i64 {
+        let expr = expr.trim();
+
+        // Check for assignment: VAR = expr (but not == comparison)
+        // Pattern: identifier followed by = (not ==)
+        if let Some(eq_pos) = expr.find('=') {
+            // Make sure it's not == or !=
+            let before = &expr[..eq_pos];
+            let after_char = expr.as_bytes().get(eq_pos + 1);
+            if !before.ends_with('!')
+                && !before.ends_with('<')
+                && !before.ends_with('>')
+                && after_char != Some(&b'=')
+            {
+                let var_name = before.trim();
+                // Verify LHS is a valid variable name
+                if !var_name.is_empty()
+                    && var_name
+                        .chars()
+                        .all(|c| c.is_ascii_alphanumeric() || c == '_')
+                    && !var_name.chars().next().unwrap_or('0').is_ascii_digit()
+                {
+                    let rhs = &expr[eq_pos + 1..];
+                    let value = self.evaluate_arithmetic(rhs);
+                    self.variables
+                        .insert(var_name.to_string(), value.to_string());
+                    return value;
+                }
+            }
+        }
+
+        self.evaluate_arithmetic(expr)
+    }
+
     /// Evaluate a simple arithmetic expression
     fn evaluate_arithmetic(&self, expr: &str) -> i64 {
         // Simple arithmetic evaluation - handles basic operations
diff --git a/crates/bashkit/tests/spec_cases/bash/arithmetic.test.sh b/crates/bashkit/tests/spec_cases/bash/arithmetic.test.sh
index b587ee42..1efb533f 100644
--- a/crates/bashkit/tests/spec_cases/bash/arithmetic.test.sh
+++ b/crates/bashkit/tests/spec_cases/bash/arithmetic.test.sh
@@ -118,7 +118,6 @@ echo $((1 + 2 + 3 + 4))
 ### end
 
 ### arith_assign
-### skip: assignment inside $(()) not implemented
 # Assignment in arithmetic
 X=5; echo $((X = X + 1)); echo $X
 ### expect
diff --git a/crates/bashkit/tests/spec_tests.rs b/crates/bashkit/tests/spec_tests.rs
index 8d8d9e3d..ae4d4c8d 100644
--- a/crates/bashkit/tests/spec_tests.rs
+++ b/crates/bashkit/tests/spec_tests.rs
@@ -81,8 +81,8 @@
 //! ### herestring.test.sh (0 skipped)
 //! - [x] herestring_empty - test rewritten to verify newline behavior
 //!
-//! ### arithmetic.test.sh (1 skipped)
-//! - [ ] arith_assign - assignment inside $(()) not implemented
+//! ### arithmetic.test.sh (0 skipped)
+//! - [x] arith_assign - assignment inside $(()) implemented
 //!
 //! ### control-flow.test.sh (enabled)
 //! - [x] Control flow tests enabled (31 tests passing)

From d96d0e9579c6ce816aa8177f1d8849873c3326a9 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Wed, 18 Feb 2026 00:39:21 +0000
Subject: [PATCH 4/9] fix(interpreter): propagate exit code from command
 substitution

In bash, `x=$(false); echo $?` prints 1 because the exit code of
an assignment-only command is the exit code of the last command
substitution in its value. Previously bashkit always returned 0
for assignment-only commands.

Two changes:
1. Set last_exit_code during command substitution word expansion
2. Use last_exit_code as return code for assignment-only commands

Unskipped subst_exit_code spec test.

https://claude.ai/code/session_016hW1DMEWM7SnaK1n6fZtxk
---
 crates/bashkit/src/interpreter/mod.rs               | 13 +++++++++++--
 .../tests/spec_cases/bash/command-subst.test.sh     |  1 -
 crates/bashkit/tests/spec_tests.rs                  |  4 ++--
 3 files changed, 13 insertions(+), 5 deletions(-)

diff --git a/crates/bashkit/src/interpreter/mod.rs b/crates/bashkit/src/interpreter/mod.rs
index 8b14edf7..06afd8fd 100644
--- a/crates/bashkit/src/interpreter/mod.rs
+++ b/crates/bashkit/src/interpreter/mod.rs
@@ -1866,9 +1866,16 @@ impl Interpreter {
 
         let name = self.expand_word(&command.name).await?;
 
-        // If name is empty, this is an assignment-only command - keep permanently
+        // If name is empty, this is an assignment-only command - keep permanently.
+        // Preserve last_exit_code from any command substitution in the value
+        // (bash behavior: `x=$(false)` sets $? to 1).
         if name.is_empty() {
-            return Ok(ExecResult::ok(String::new()));
+            return Ok(ExecResult {
+                stdout: String::new(),
+                stderr: String::new(),
+                exit_code: self.last_exit_code,
+                control_flow: crate::interpreter::ControlFlow::None,
+            });
         }
 
         // Has a command: prefix assignments are temporary (bash behavior).
@@ -2510,6 +2517,8 @@ impl Interpreter {
                     for cmd in commands {
                         let cmd_result = self.execute_command(cmd).await?;
                         stdout.push_str(&cmd_result.stdout);
+                        // Propagate exit code from last command in substitution
+                        self.last_exit_code = cmd_result.exit_code;
                     }
                     // Remove trailing newline (bash behavior)
                     let trimmed = stdout.trim_end_matches('\n');
diff --git a/crates/bashkit/tests/spec_cases/bash/command-subst.test.sh b/crates/bashkit/tests/spec_cases/bash/command-subst.test.sh
index 82e6dd35..a115ed55 100644
--- a/crates/bashkit/tests/spec_cases/bash/command-subst.test.sh
+++ b/crates/bashkit/tests/spec_cases/bash/command-subst.test.sh
@@ -64,7 +64,6 @@ matched
 ### end
 
 ### subst_exit_code
-### skip: exit code propagation from command substitution not implemented
 # Exit code from command substitution
 result=$(false); echo $?
 ### expect
diff --git a/crates/bashkit/tests/spec_tests.rs b/crates/bashkit/tests/spec_tests.rs
index ae4d4c8d..aecb7d54 100644
--- a/crates/bashkit/tests/spec_tests.rs
+++ b/crates/bashkit/tests/spec_tests.rs
@@ -70,8 +70,8 @@
 //! ### path.test.sh (2 skipped)
 //! - [ ] basename_no_args, dirname_no_args - error handling not implemented
 //!
-//! ### command-subst.test.sh (2 skipped)
-//! - [ ] subst_exit_code - exit code propagation needs work
+//! ### command-subst.test.sh (1 skipped)
+//! - [x] subst_exit_code - exit code propagation implemented
 //! - [ ] subst_backtick - backtick substitution not implemented
 //!
 //! ### arrays.test.sh (1 skipped)

From 62b18ca4564668e545a5d8a36c4fb4c4d9278a69 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Wed, 18 Feb 2026 00:41:07 +0000
Subject: [PATCH 5/9] feat(sort): add -f flag for case-insensitive sorting

Implement sort -f (fold case) which compares lines case-insensitively
while preserving original casing in output. Uses to_lowercase() for
comparison keys.

Unskipped sort_case_insensitive spec test.

https://claude.ai/code/session_016hW1DMEWM7SnaK1n6fZtxk
---
 crates/bashkit/src/builtins/sortuniq.rs        | 18 ++++++++++++++++--
 .../tests/spec_cases/bash/sortuniq.test.sh     |  1 -
 crates/bashkit/tests/spec_tests.rs             |  7 ++++---
 3 files changed, 20 insertions(+), 6 deletions(-)

diff --git a/crates/bashkit/src/builtins/sortuniq.rs b/crates/bashkit/src/builtins/sortuniq.rs
index e67a8510..6bf50c49 100644
--- a/crates/bashkit/src/builtins/sortuniq.rs
+++ b/crates/bashkit/src/builtins/sortuniq.rs
@@ -11,11 +11,12 @@ use crate::interpreter::ExecResult;
 
 /// The sort builtin - sort lines of text.
 ///
-/// Usage: sort [-rnuV] [FILE...]
+/// Usage: sort [-fnruV] [FILE...]
 ///
 /// Options:
-///   -r   Reverse the result of comparisons
+///   -f   Fold lower case to upper case characters (case insensitive)
 ///   -n   Compare according to string numerical value
+///   -r   Reverse the result of comparisons
 ///   -u   Output only unique lines (like sort | uniq)
 ///   -V   Natural sort of version numbers
 pub struct Sort;
@@ -35,6 +36,10 @@ impl Builtin for Sort {
             .args
             .iter()
             .any(|a| a.contains('u') && a.starts_with('-'));
+        let fold_case = ctx
+            .args
+            .iter()
+            .any(|a| a.contains('f') && a.starts_with('-'));
 
         let files: Vec<_> = ctx.args.iter().filter(|a| !a.starts_with('-')).collect();
 
@@ -88,6 +93,8 @@ impl Builtin for Sort {
                     .partial_cmp(&b_num)
                     .unwrap_or(std::cmp::Ordering::Equal)
             });
+        } else if fold_case {
+            all_lines.sort_by(|a, b| a.to_lowercase().cmp(&b.to_lowercase()));
         } else {
             all_lines.sort();
         }
@@ -309,6 +316,13 @@ mod tests {
         assert_eq!(result.stdout, "apple\nbanana\ncherry\n");
     }
 
+    #[tokio::test]
+    async fn test_sort_fold_case() {
+        let result = run_sort(&["-f"], Some("Banana\napple\nCherry\n")).await;
+        assert_eq!(result.exit_code, 0);
+        assert_eq!(result.stdout, "apple\nBanana\nCherry\n");
+    }
+
     #[tokio::test]
     async fn test_uniq_basic() {
         let result = run_uniq(&[], Some("a\na\nb\nb\nb\nc\n")).await;
diff --git a/crates/bashkit/tests/spec_cases/bash/sortuniq.test.sh b/crates/bashkit/tests/spec_cases/bash/sortuniq.test.sh
index f9012cc9..eab7c428 100644
--- a/crates/bashkit/tests/spec_cases/bash/sortuniq.test.sh
+++ b/crates/bashkit/tests/spec_cases/bash/sortuniq.test.sh
@@ -112,7 +112,6 @@ printf '1\n10\n2\n5\n' | sort -rn
 ### end
 
 ### sort_case_insensitive
-### skip: sort -f (case insensitive) not implemented
 printf 'Banana\napple\nCherry\n' | sort -f
 ### expect
 apple
diff --git a/crates/bashkit/tests/spec_tests.rs b/crates/bashkit/tests/spec_tests.rs
index aecb7d54..82321610 100644
--- a/crates/bashkit/tests/spec_tests.rs
+++ b/crates/bashkit/tests/spec_tests.rs
@@ -28,9 +28,10 @@
 //! - [ ] tr_truncate_set2 - tr truncation behavior differs
 //! - [ ] cut_only_delimited, cut_zero_terminated - not implemented
 //!
-//! ### sortuniq.test.sh (14 skipped) - sort/uniq flags
-//! - [ ] sort -f, -t, -k, -s, -c, -m, -h, -M, -o, -z - not implemented
-//! - [ ] uniq -d, -u, -i, -f - not implemented
+//! ### sortuniq.test.sh (13 skipped) - sort/uniq flags
+//! - [x] sort -f - case insensitive sort implemented
+//! - [ ] sort -t, -k, -s, -c, -m, -h, -M, -o, -z - not implemented
+//! - [ ] uniq -i, -f - not implemented (note: -d, -u already work)
 //!
 //! ### echo.test.sh (4 skipped)
 //! - [x] echo_combined_en, echo_combined_ne - combined flag handling fixed

From 14be5b66b8ee95376eca1560f072a1a6ba99e335 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Wed, 18 Feb 2026 00:41:51 +0000
Subject: [PATCH 6/9] fix(tests): unskip uniq -d/-u spec tests (already
 implemented)

The uniq -d (only duplicates) and -u (only unique) flags were already
implemented in the Rust code with passing unit tests, but the spec
tests still had stale skip markers. Removed the skip directives and
verified both spec tests pass.

https://claude.ai/code/session_016hW1DMEWM7SnaK1n6fZtxk
---
 crates/bashkit/tests/spec_cases/bash/sortuniq.test.sh | 2 --
 crates/bashkit/tests/spec_tests.rs                    | 5 +++--
 2 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/crates/bashkit/tests/spec_cases/bash/sortuniq.test.sh b/crates/bashkit/tests/spec_cases/bash/sortuniq.test.sh
index eab7c428..b69ba4ac 100644
--- a/crates/bashkit/tests/spec_cases/bash/sortuniq.test.sh
+++ b/crates/bashkit/tests/spec_cases/bash/sortuniq.test.sh
@@ -165,7 +165,6 @@ d
 ### end
 
 ### uniq_duplicate_only
-### skip: uniq -d (only duplicates) not implemented
 printf 'a\na\nb\nc\nc\n' | uniq -d
 ### expect
 a
@@ -173,7 +172,6 @@ c
 ### end
 
 ### uniq_unique_only
-### skip: uniq -u (only unique) not implemented
 printf 'a\na\nb\nc\nc\n' | uniq -u
 ### expect
 b
diff --git a/crates/bashkit/tests/spec_tests.rs b/crates/bashkit/tests/spec_tests.rs
index 82321610..7da966b0 100644
--- a/crates/bashkit/tests/spec_tests.rs
+++ b/crates/bashkit/tests/spec_tests.rs
@@ -28,10 +28,11 @@
 //! - [ ] tr_truncate_set2 - tr truncation behavior differs
 //! - [ ] cut_only_delimited, cut_zero_terminated - not implemented
 //!
-//! ### sortuniq.test.sh (13 skipped) - sort/uniq flags
+//! ### sortuniq.test.sh (11 skipped) - sort/uniq flags
 //! - [x] sort -f - case insensitive sort implemented
 //! - [ ] sort -t, -k, -s, -c, -m, -h, -M, -o, -z - not implemented
-//! - [ ] uniq -i, -f - not implemented (note: -d, -u already work)
+//! - [x] uniq -d, -u - already implemented, tests unskipped
+//! - [ ] uniq -i, -f - not implemented
 //!
 //! ### echo.test.sh (4 skipped)
 //! - [x] echo_combined_en, echo_combined_ne - combined flag handling fixed

From 9ec0b0c9f667c384661af6327ed876546e42332b Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Wed, 18 Feb 2026 00:43:00 +0000
Subject: [PATCH 7/9] chore(interpreter): resolve background execution and
 shell options TODOs

Replace TODO comments with proper documentation explaining design
decisions:

1. Background execution (&): runs synchronously in virtual mode since
   OS process spawning is excluded from the sandbox by design.

2. Shell options (-e, -x, -v, -u, etc.): documented why each option
   is accepted but not enforced, with specific notes on what
   implementation would require.

https://claude.ai/code/session_016hW1DMEWM7SnaK1n6fZtxk
---
 crates/bashkit/src/interpreter/mod.rs | 18 +++++++++++++-----
 1 file changed, 13 insertions(+), 5 deletions(-)

diff --git a/crates/bashkit/src/interpreter/mod.rs b/crates/bashkit/src/interpreter/mod.rs
index 06afd8fd..07070831 100644
--- a/crates/bashkit/src/interpreter/mod.rs
+++ b/crates/bashkit/src/interpreter/mod.rs
@@ -1307,10 +1307,16 @@ impl Interpreter {
                     noexec = true;
                     idx += 1;
                 }
-                // Accept but ignore these options (limited/no support in virtual mode)
-                // TODO: These options are accepted but not enforced in virtual mode
-                // -e (errexit), -x (xtrace), -v (verbose), -u (nounset)
-                // Would need interpreter changes to fully implement
+                // Accept but ignore these options. These are recognized for
+                // compatibility with scripts that set them, but not enforced
+                // in virtual mode:
+                // -e (errexit): would need per-command exit code checking
+                // -x (xtrace): would need trace output to stderr
+                // -v (verbose): would need input echoing
+                // -u (nounset): would need unset variable detection
+                // -o (option): would need set -o pipeline
+                // -i (interactive): not applicable in virtual mode
+                // -s (stdin): read from stdin (implicit behavior)
                 "-e" | "-x" | "-v" | "-u" | "-o" | "-i" | "-s" => {
                     idx += 1;
                 }
@@ -1732,7 +1738,9 @@ impl Interpreter {
                 ListOperator::Or => exit_code != 0,
                 ListOperator::Semicolon => true,
                 ListOperator::Background => {
-                    // TODO: Implement background execution
+                    // Background (&) runs command synchronously in virtual mode.
+                    // True process backgrounding requires OS process spawning which
+                    // is excluded from the sandboxed virtual environment by design.
                     true
                 }
             };

From 64195ea64d4f27e95c155dc000e3cc972cef87bb Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Wed, 18 Feb 2026 00:43:25 +0000
Subject: [PATCH 8/9] chore(deny): replace license clarification TODO with
 documentation

The commented-out [[licenses.clarify]] template with a TODO was a
placeholder that's never been needed. Replace with a clear comment
explaining when clarifications would be added.

https://claude.ai/code/session_016hW1DMEWM7SnaK1n6fZtxk
---
 deny.toml | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/deny.toml b/deny.toml
index ef49a455..2dfc5eaa 100644
--- a/deny.toml
+++ b/deny.toml
@@ -24,11 +24,9 @@ confidence-threshold = 0.8
 # Allow specific exceptions
 exceptions = []
 
-# TODO: Add clarifications as needed
-# [[licenses.clarify]]
-# name = "some-crate"
-# expression = "MIT"
-# license-files = [{ path = "LICENSE", hash = 0x00000000 }]
+# No license clarifications currently needed. All dependencies have
+# clear license metadata. Add [[licenses.clarify]] entries here if
+# cargo-deny reports ambiguous licenses for any dependency.
 
 [advisories]
 # Ignore unmaintained transitive dependencies we can't control

From c86ca9e8b348979c34fde9b0da63709f4cc47126 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Wed, 18 Feb 2026 00:48:22 +0000
Subject: [PATCH 9/9] chore: update skipped test count and fix clippy lint

Update spec_tests.rs total from 87 to 76 skipped tests (11 unskipped
in this branch). Fix clippy unnecessary_sort_by lint in sort -f.

https://claude.ai/code/session_016hW1DMEWM7SnaK1n6fZtxk
---
 crates/bashkit/src/builtins/sortuniq.rs | 2 +-
 crates/bashkit/tests/spec_tests.rs      | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/bashkit/src/builtins/sortuniq.rs b/crates/bashkit/src/builtins/sortuniq.rs
index 6bf50c49..75fdc4ab 100644
--- a/crates/bashkit/src/builtins/sortuniq.rs
+++ b/crates/bashkit/src/builtins/sortuniq.rs
@@ -94,7 +94,7 @@ impl Builtin for Sort {
                     .unwrap_or(std::cmp::Ordering::Equal)
             });
         } else if fold_case {
-            all_lines.sort_by(|a, b| a.to_lowercase().cmp(&b.to_lowercase()));
+            all_lines.sort_by_key(|a| a.to_lowercase());
         } else {
             all_lines.sort();
         }
diff --git a/crates/bashkit/tests/spec_tests.rs b/crates/bashkit/tests/spec_tests.rs
index 7da966b0..7af0c1b5 100644
--- a/crates/bashkit/tests/spec_tests.rs
+++ b/crates/bashkit/tests/spec_tests.rs
@@ -8,7 +8,7 @@
 //! - `### skip: reason` - Skip test entirely (not run in any test)
 //! - `### bash_diff: reason` - Known difference from real bash (runs in spec tests, excluded from comparison)
 //!
-//! ## Skipped Tests TODO (87 total)
+//! ## Skipped Tests TODO (76 total)
 //!
 //! The following tests are skipped and need fixes:
 //!