diff --git a/crates/bashkit/src/builtins/sortuniq.rs b/crates/bashkit/src/builtins/sortuniq.rs
index e67a8510..75fdc4ab 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_key(|a| a.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/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/src/interpreter/mod.rs b/crates/bashkit/src/interpreter/mod.rs
index 184df8e2..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
                 }
             };
@@ -1866,9 +1874,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,14 +2525,17 @@ 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');
                     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 +3013,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_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_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_cases/bash/sortuniq.test.sh b/crates/bashkit/tests/spec_cases/bash/sortuniq.test.sh
index f9012cc9..b69ba4ac 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
@@ -166,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
@@ -174,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_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..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:
 //!
@@ -28,9 +28,11 @@
 //! - [ ] 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 (11 skipped) - sort/uniq flags
+//! - [x] sort -f - case insensitive sort implemented
+//! - [ ] sort -t, -k, -s, -c, -m, -h, -M, -o, -z - not implemented
+//! - [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
@@ -43,11 +45,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
@@ -70,19 +72,19 @@
 //! ### 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)
 //! - [ ] 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
+//! ### arithmetic.test.sh (0 skipped)
+//! - [x] arith_assign - assignment inside $(()) implemented
 //!
 //! ### control-flow.test.sh (enabled)
 //! - [x] Control flow tests enabled (31 tests passing)
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