From 9be3c436c0a6e4ef09089d62341d7749797c7d4d Mon Sep 17 00:00:00 2001
From: Mykhailo Chalyi <mike@chaliy.name>
Date: Fri, 9 Oct 2026 00:31:50 +0000
Subject: [PATCH] fix(parser): expand aliases per line and close final Oils
 spec gaps

Aliases expand at parse time and the rest of a script is re-read from the
next line when alias/extglob options change, as bash reads line by line.
Also: !( only under extglob, extglob no-match and [C\-D] globs,
globskipdots, failglob abandons its line, for { } bodies and newline
before in, (( )) redirects, a[ fragments, array subscript side effects,
a[i]=x cmd, quoted splats in declare literals, tilde in ${u-~:~} and =~,
errexit under !, per-call function redirects, ambiguous > "$@", set -v
echo, top-level LINENO for (( ))/[[ ]], and compgen -A builtin lists only
bash builtins. Oils spec 95.8% to 97.3% (2578 to 2618 of 2692).
---
 crates/bashkit/src/builtins/compgen.rs        |   10 +-
 crates/bashkit/src/interpreter/completion.rs  |   18 +-
 crates/bashkit/src/interpreter/declare.rs     |   29 +-
 crates/bashkit/src/interpreter/expansion.rs   |  114 +-
 crates/bashkit/src/interpreter/glob.rs        |   12 +
 crates/bashkit/src/interpreter/history.rs     |    7 +
 crates/bashkit/src/interpreter/mod.rs         |  773 +++---
 crates/bashkit/src/interpreter/redirection.rs |   11 +-
 crates/bashkit/src/lib.rs                     |   12 +-
 crates/bashkit/src/parser/ast.rs              |   13 +
 crates/bashkit/src/parser/budget.rs           |    2 +
 crates/bashkit/src/parser/lexer.rs            |  237 +-
 crates/bashkit/src/parser/mod.rs              |  260 +-
 .../tests/integration/compgen_tests.rs        |   28 +-
 .../spec_cases/bash/oils-final-gaps.test.sh   |  207 ++
 knowledge/foundations/parser.md               |   27 +
 knowledge/log.md                              |    4 +
 knowledge/operations/limitations.md           |   24 +-
 knowledge/operations/oils-spec.md             |   15 +-
 ...ls-spec-linux-x86_64-20261009T010244Z.json | 2330 +++++++++++++++++
 ...oils-spec-linux-x86_64-20261009T010244Z.md |  167 ++
 21 files changed, 3760 insertions(+), 540 deletions(-)
 create mode 100644 crates/bashkit/tests/spec_cases/bash/oils-final-gaps.test.sh
 create mode 100644 scripts/oils-spec/results/oils-spec-linux-x86_64-20261009T010244Z.json
 create mode 100644 scripts/oils-spec/results/oils-spec-linux-x86_64-20261009T010244Z.md

diff --git a/crates/bashkit/src/builtins/compgen.rs b/crates/bashkit/src/builtins/compgen.rs
index d6e3b28a9..0aa4db5ed 100644
--- a/crates/bashkit/src/builtins/compgen.rs
+++ b/crates/bashkit/src/builtins/compgen.rs
@@ -140,13 +140,21 @@ impl Builtin for Compgen {
         // -b / -A builtin (and -c): names from the live registry — the same
         // source as `Bash::builtin_names()` — never a hardcoded list, which
         // drifted (109 names vs 156 registered) before this was wired up.
+        // -b / -A builtin keep the ones bash itself has built in.
         // `ctx.shell` is None only for custom/external builtin contexts,
         // which have no interpreter introspection by design.
         if (gen_builtins || gen_commands)
             && let Some(ref shell) = ctx.shell
         {
             for name in shell.builtin_names() {
-                if name.starts_with(pfx) {
+                // `-A builtin` is bash's builtins only; the other registered
+                // commands stand in for programs, which only `-c` lists.
+                // A host-registered command is the embedder's builtin.
+                let bash_builtin = super::BASH_BUILTIN_NAMES.contains(&name.as_str())
+                    || shell
+                        .host_builtins
+                        .is_some_and(|r| r.lookup(&name).is_some());
+                if name.starts_with(pfx) && (gen_commands || bash_builtin) {
                     completions.push(name);
                 }
             }
diff --git a/crates/bashkit/src/interpreter/completion.rs b/crates/bashkit/src/interpreter/completion.rs
index 81225ae5a..fb2dd8c01 100644
--- a/crates/bashkit/src/interpreter/completion.rs
+++ b/crates/bashkit/src/interpreter/completion.rs
@@ -966,9 +966,21 @@ impl Interpreter {
                 .iter()
                 .map(|s| s.to_string())
                 .collect(),
-            // Live registry, not bash's list: bashkit's `awk`/`grep` are
-            // builtins here (compgen_tests.rs pins this contract).
-            "builtin" | "enabled" => self.builtin_names(),
+            // The live registry minus the commands that stand in for
+            // programs (`awk`, `grep`): bash's builtins, plus builtins the
+            // embedder registered.
+            "builtin" | "enabled" => self
+                .builtin_names()
+                .into_iter()
+                .filter(|n| {
+                    crate::builtins::BASH_BUILTIN_NAMES.contains(&n.as_str())
+                        || self.custom_builtin_names.contains(n)
+                        || self
+                            .host_builtins
+                            .as_ref()
+                            .is_some_and(|r| r.lookup(n).is_some())
+                })
+                .collect(),
             "helptopic" => crate::builtins::BASH_BUILTIN_NAMES
                 .iter()
                 .map(|s| s.to_string())
diff --git a/crates/bashkit/src/interpreter/declare.rs b/crates/bashkit/src/interpreter/declare.rs
index 75879d90b..30f140a4d 100644
--- a/crates/bashkit/src/interpreter/declare.rs
+++ b/crates/bashkit/src/interpreter/declare.rs
@@ -1565,7 +1565,7 @@ impl Interpreter {
             for field in self.ifs_split_limited(&expanded, limit)? {
                 match self.expand_glob_item(&field, false).await {
                     Ok(items) => fields.extend(items),
-                    Err(_) => fields.push(field),
+                    Err(pat) => return Err(self.failglob_abort(&pat)),
                 }
                 if fields.len() >= limit {
                     break;
@@ -1574,8 +1574,12 @@ impl Interpreter {
             fields.truncate(limit);
             return Ok(fields);
         }
-        if is_splat {
-            return self.expand_word_to_fields(word).await;
+        // `"${a[@]:1}"`, `"x${a[@]}y"`: a quoted word with an `@` splat
+        // keeps one field per element.
+        if is_splat || word.quoted && !word.has_unquoted_glob && word_has_at_splat(word) {
+            let mut fields = self.expand_word_to_fields(word).await?;
+            fields.truncate(limit);
+            return Ok(fields);
         }
         let value = self.expand_word(word).await?;
         let literal_only = word.parts.iter().all(|p| matches!(p, WordPart::Literal(_)));
@@ -1592,11 +1596,18 @@ impl Interpreter {
             .await
         {
             Ok(items) => items,
-            Err(_) => vec![value],
+            Err(pat) => return Err(self.failglob_abort(&pat)),
         };
         fields.truncate(limit);
         Ok(fields)
     }
+
+    /// `shopt -s failglob` with no match in an array literal: bash reports
+    /// `no match` and abandons the rest of the line, status 1.
+    fn failglob_abort(&mut self, pattern: &str) -> crate::error::Error {
+        self.last_exit_code = 1;
+        crate::error::Error::LineAbort(self.diag(format!("no match: {pattern}\n")))
+    }
 }
 
 /// `word` with its unquoted literal `~`s taken literally.
@@ -1621,6 +1632,16 @@ fn no_tilde_word(word: &Word) -> std::borrow::Cow<'_, Word> {
     std::borrow::Cow::Owned(out)
 }
 
+/// A part that expands to one field per element inside double quotes.
+fn word_has_at_splat(word: &Word) -> bool {
+    word.parts.iter().any(|p| match p {
+        WordPart::ArrayAccess { index, .. } => index == "@",
+        WordPart::Variable(n) => n == "@",
+        WordPart::Substring { name, .. } => name == "@" || name.ends_with("[@]"),
+        _ => false,
+    })
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/crates/bashkit/src/interpreter/expansion.rs b/crates/bashkit/src/interpreter/expansion.rs
index 68dd6dd36..0b7146176 100644
--- a/crates/bashkit/src/interpreter/expansion.rs
+++ b/crates/bashkit/src/interpreter/expansion.rs
@@ -260,7 +260,20 @@ impl Interpreter {
     fn needs_glob_escape(ch: char) -> bool {
         matches!(
             ch,
-            '\\' | '*' | '?' | '[' | ']' | '{' | '}' | ',' | '@' | '!' | '+' | '(' | ')' | '|'
+            '\\' | '*'
+                | '?'
+                | '['
+                | ']'
+                | '{'
+                | '}'
+                | ','
+                | '@'
+                | '!'
+                | '+'
+                | '('
+                | ')'
+                | '|'
+                | '-'
         )
     }
 
@@ -519,6 +532,14 @@ impl Interpreter {
                     // values read into arithmetic).
                     let value = if index.contains("$(") && !self.is_assoc_array(name) {
                         self.array_access_after_subst(name, index).await?
+                    } else if arith_has_side_effect(index)
+                        && !self.is_assoc_array(name)
+                        && !self.scoped.namerefs.contains_key(name)
+                    {
+                        // `${a[b=2]}`: the subscript is evaluated once, with
+                        // its assignments (bash).
+                        let idx = self.evaluate_arithmetic_with_assign(index);
+                        self.expand_array_access_part(name, &idx.to_string())
                     } else {
                         self.expand_array_access_part(name, index)
                     };
@@ -868,13 +889,57 @@ impl Interpreter {
     /// its tildes resolved: a leading `~` and the `~` after each `:` of an
     /// unquoted literal. Literals holding a `~` become quoted, so later
     /// expansion leaves them alone.
+    /// A `${v-word}` operand with each unquoted `~` after a `:` replaced
+    /// by its directory.
+    fn tilde_operand_after_colons(&self, operand: &str) -> Option<String> {
+        let b = operand.as_bytes();
+        let mut out = String::new();
+        let mut copied = 0;
+        let mut quote: Option<u8> = None;
+        let mut changed = false;
+        let mut i = 0;
+        while i < b.len() {
+            match (quote, b[i]) {
+                (None, b'\\') => i += 1,
+                (None, q @ (b'\'' | b'"')) => quote = Some(q),
+                (Some(q), c) if c == q => quote = None,
+                (None, b':') if b.get(i + 1) == Some(&b'~') => {
+                    let start = i + 2;
+                    let end = operand[start..]
+                        .find(['/', ':', '}', '$', '\'', '"'])
+                        .map_or(operand.len(), |k| start + k);
+                    // The operand is re-read as a word: a directory that
+                    // would read differently there keeps its `~`.
+                    if matches!(b.get(end), None | Some(b'/' | b':'))
+                        && let Some(dir) = self.tilde_dir(&operand[start..end])
+                        && !dir.contains(['$', '`', '\\', '\'', '"', '*', '?', '[', '}'])
+                    {
+                        out.push_str(&operand[copied..=i]);
+                        out.push_str(&dir);
+                        copied = end;
+                        changed = true;
+                        i = end;
+                        continue;
+                    }
+                }
+                _ => {}
+            }
+            i += 1;
+        }
+        changed.then(|| {
+            out.push_str(&operand[copied..]);
+            out
+        })
+    }
+
     pub(super) fn tilde_assignment_value<'w>(&self, word: &'w Word) -> std::borrow::Cow<'w, Word> {
         use std::borrow::Cow;
         let quoted_at = |i: usize| Self::part_is_quoted(word, i);
-        let has_tilde =
-            word.parts.iter().enumerate().any(
-                |(i, p)| matches!(p, WordPart::Literal(s) if !quoted_at(i) && s.contains('~')),
-            );
+        let has_tilde = word.parts.iter().enumerate().any(|(i, p)| match p {
+            WordPart::Literal(s) => !quoted_at(i) && s.contains('~'),
+            WordPart::ParameterExpansion { operand, .. } => !quoted_at(i) && operand.contains(":~"),
+            _ => false,
+        });
         if !has_tilde {
             return Cow::Borrowed(word);
         }
@@ -882,6 +947,28 @@ impl Interpreter {
         out.part_quoted = (0..word.parts.len()).map(quoted_at).collect();
         let n = word.parts.len();
         for (i, part) in word.parts.iter().enumerate() {
+            if let WordPart::ParameterExpansion {
+                name,
+                operator:
+                    op @ (ParameterOp::UseDefault
+                    | ParameterOp::AssignDefault
+                    | ParameterOp::UseReplacement),
+                operand,
+                colon_variant,
+            } = part
+                && !quoted_at(i)
+                && let Some(expanded) = self.tilde_operand_after_colons(operand)
+            {
+                // `x=${undef-~:~}`: the operand of an assignment value
+                // expands `~` after each `:` too.
+                out.parts[i] = WordPart::ParameterExpansion {
+                    name: name.clone(),
+                    operator: op.clone(),
+                    operand: expanded,
+                    colon_variant: *colon_variant,
+                };
+                continue;
+            }
             let WordPart::Literal(s) = part else {
                 continue;
             };
@@ -3516,6 +3603,23 @@ impl Interpreter {
     }
 }
 
+/// Whether arithmetic text assigns: `b=2`, `i+=1`, `i++`, `--i`.
+fn arith_has_side_effect(expr: &str) -> bool {
+    if expr.contains("++") || expr.contains("--") {
+        return true;
+    }
+    let b = expr.as_bytes();
+    b.iter().enumerate().any(|(i, &c)| {
+        c == b'='
+            && b.get(i + 1) != Some(&b'=')
+            && !matches!(
+                i.checked_sub(1).map(|j| b[j]),
+                Some(b'=' | b'!' | b'<' | b'>')
+            )
+            || c == b'=' && i >= 2 && matches!(&b[i - 2..i], b"<<" | b">>")
+    })
+}
+
 #[cfg(test)]
 mod expansion_charge_tests {
     use super::*;
diff --git a/crates/bashkit/src/interpreter/glob.rs b/crates/bashkit/src/interpreter/glob.rs
index fb26c63a2..49ece9e01 100644
--- a/crates/bashkit/src/interpreter/glob.rs
+++ b/crates/bashkit/src/interpreter/glob.rs
@@ -929,6 +929,7 @@ impl Interpreter {
                         | '('
                         | ')'
                         | '|'
+                        | '-'
                 )
             {
                 result.push(next);
@@ -1040,6 +1041,10 @@ impl Interpreter {
                 // Dotfiles are hidden per component unless dotglob is set or this
                 // component explicitly starts with '.'.
                 let component_starts_with_dot = component.starts_with('.');
+                // `shopt -u globskipdots`: a pattern that starts with `.` also
+                // matches `.` and `..`, which the VFS `read_dir` never lists.
+                let dot_entries = component_starts_with_dot
+                    && !crate::builtins::shopt_on(&self.scoped.variables, "globskipdots");
 
                 for (dir, out) in &candidates {
                     let entries = match self.fs.read_dir(dir).await {
@@ -1048,6 +1053,13 @@ impl Interpreter {
                     };
 
                     let mut matched: Vec<String> = Vec::new();
+                    if dot_entries {
+                        for dot in [".", ".."] {
+                            if self.glob_match_impl(dot, component, opts, 0) {
+                                matched.push(dot.to_string());
+                            }
+                        }
+                    }
                     for entry in entries {
                         if entry.name.starts_with('.') && !dotglob && !component_starts_with_dot {
                             continue;
diff --git a/crates/bashkit/src/interpreter/history.rs b/crates/bashkit/src/interpreter/history.rs
index b3137b7a9..0cf2583ed 100644
--- a/crates/bashkit/src/interpreter/history.rs
+++ b/crates/bashkit/src/interpreter/history.rs
@@ -73,6 +73,13 @@ impl LineReader {
         self.script_addr == script as *const Script as usize
     }
 
+    /// The top level re-read its rest into `to` (see `reread_script_rest`).
+    pub(super) fn retarget(&mut self, from: &Script, to: &Script) {
+        if self.reads(from) {
+            self.script_addr = to as *const Script as usize;
+        }
+    }
+
     /// Source lines `first..=last` (1-based), without the final newline.
     fn lines(&mut self, first: usize, last: usize) -> String {
         if self.line_starts.is_empty() {
diff --git a/crates/bashkit/src/interpreter/mod.rs b/crates/bashkit/src/interpreter/mod.rs
index e8df0d6a0..fa8ebff93 100644
--- a/crates/bashkit/src/interpreter/mod.rs
+++ b/crates/bashkit/src/interpreter/mod.rs
@@ -931,6 +931,21 @@ fn is_dev_null(path: &Path) -> bool {
 /// Decision: these paths are resolved at the interpreter level like
 /// `/dev/null`, never through the VFS. Writing them as regular files silently
 /// swallowed `echo err > /dev/stderr`, a pattern agents use constantly.
+/// The script a body runs (see `Interpreter::reread_script_rest`).
+enum ScriptView<'a> {
+    Parsed(&'a Script),
+    Reread(Box<Script>),
+}
+
+impl ScriptView<'_> {
+    fn get(&self) -> &Script {
+        match self {
+            ScriptView::Parsed(s) => s,
+            ScriptView::Reread(s) => s,
+        }
+    }
+}
+
 fn dev_fd_alias(path: &Path) -> Option<i32> {
     let normalized = normalize_dev_path(path);
     match normalized.to_str()? {
@@ -1760,9 +1775,6 @@ pub struct Interpreter {
     operand_substs: std::collections::VecDeque<String>,
     /// PIPESTATUS: exit codes of the last pipeline's commands
     pipestatus: Vec<i32>,
-    /// Aliases currently being expanded (prevents infinite recursion).
-    /// When alias `foo` expands to `foo bar`, the inner `foo` is not re-expanded.
-    expanding_aliases: HashSet<String>,
     /// THREAT[TM-DOS-023]: Bounded cache for repeated `[[ value =~ pattern ]]` evaluations.
     regex_cache: RuntimeRegexCache,
     /// Command history entries for the current session.
@@ -1854,6 +1866,8 @@ pub struct Interpreter {
     /// nested AND-OR lists can suppress ERR traps without weakening top-level
     /// final-command errexit behavior.
     condition_sequence_depth: usize,
+    /// `set -e` stopped a command sequence (see the `!` pipeline arm).
+    errexit_fired: bool,
     /// Deferred output process substitutions: after a command writes to the
     /// substitution's fd, run these commands with what it wrote as stdin.
     /// Each entry is (write buffer, commands_to_run).
@@ -2447,7 +2461,6 @@ impl Interpreter {
             nounset_error: None,
             operand_substs: std::collections::VecDeque::new(),
             pipestatus: Vec::new(),
-            expanding_aliases: HashSet::new(),
             regex_cache: RuntimeRegexCache::default(),
             history: Vec::new(),
             history_bytes: 0,
@@ -2479,6 +2492,7 @@ impl Interpreter {
             debug_trap_dormant: false,
             err_trap_skip_stage: false,
             condition_sequence_depth: 0,
+            errexit_fired: false,
             deferred_proc_subs: Vec::new(),
             proc_subs,
             random_state: AtomicU32::new(random_seed),
@@ -2663,7 +2677,6 @@ impl Interpreter {
             nounset_error: None,
             operand_substs: std::collections::VecDeque::new(),
             pipestatus: Vec::new(),
-            expanding_aliases: HashSet::new(),
             regex_cache: RuntimeRegexCache::default(),
             history: Vec::new(),
             history_bytes: 0,
@@ -2697,6 +2710,7 @@ impl Interpreter {
             debug_trap_dormant: self.debug_trap_dormant,
             err_trap_skip_stage: false,
             condition_sequence_depth: self.condition_sequence_depth,
+            errexit_fired: false,
             deferred_proc_subs: Vec::new(),
             proc_subs: job_proc_subs,
             random_state: AtomicU32::new(random_seed),
@@ -3839,6 +3853,190 @@ impl Interpreter {
     /// Used by `execute_source` and nested shell contexts.
     /// `run_exit_trap`: whether this shell context runs its EXIT trap.
     /// `fire_exit_hook`: whether `exit` notifies host-level on_exit hooks.
+    /// bash parses a script a line at a time, so `alias x=...` or
+    /// `shopt -s extglob` on one line changes how the next lines parse.
+    /// When those options differ from the ones `view` was parsed with and
+    /// command `index` starts a new line, re-read the rest of the source
+    /// from there with the current options.
+    #[inline(never)]
+    fn reread_script_rest(
+        &mut self,
+        view: &mut ScriptView<'_>,
+        index: &mut usize,
+        parsed_with: &mut crate::parser::ParseOptions,
+    ) -> Result<()> {
+        let script = view.get();
+        let Some(source) = script.source.clone() else {
+            return Ok(());
+        };
+        // Past the last command `command_starts` may hold where a syntax
+        // error stopped the parse: that rest is re-read too.
+        let Some(&(offset, line)) = script.command_starts.get(*index) else {
+            return Ok(());
+        };
+        let prev_end = script
+            .command_end_lines
+            .get(index.saturating_sub(1))
+            .copied()
+            .unwrap_or(0);
+        if line <= prev_end {
+            return Ok(());
+        }
+        let now = self.parse_options();
+        if now == *parsed_with {
+            return Ok(());
+        }
+        let Some(rest) = source.get(offset..) else {
+            return Ok(());
+        };
+        // THREAT[TM-DOS-030]: Propagate interpreter parser limits
+        let (mut reread, err) = Parser::with_limits(
+            rest,
+            self.limits.max_ast_depth,
+            self.limits.max_parser_operations,
+        )
+        .with_execution_budget(self.execution_budget.clone())
+        .with_options(now.clone())
+        .starting_at_line(line)
+        .parse_recovering();
+        // The syntax error keeps the `who:` its first report used.
+        let who = script
+            .trailing_error
+            .as_deref()
+            .and_then(|m| m.split_once(": line ").map(|(w, _)| w.to_string()))
+            .unwrap_or_else(|| self.diag_name());
+        match err {
+            None => {}
+            Some(e @ crate::error::Error::Parse { .. }) => {
+                reread.trailing_error = Some(
+                    e.syntax_report(&who, &source)
+                        .unwrap_or_else(|| format!("{who}: syntax error: {e}\n")),
+                );
+            }
+            Some(e) => return Err(e),
+        }
+        // THREAT[TM-DOS-031]: the re-read text (aliases expanded) gets the
+        // static budget check the first parse got; over budget, the rest
+        // of the script is refused with a diagnostic, like a syntax error.
+        if let Err(e) = crate::parser::validate_budget(&reread, &self.limits) {
+            reread.commands.clear();
+            reread.command_end_lines.clear();
+            reread.command_starts.clear();
+            reread.trailing_error = Some(self.diag(format!("budget validation failed: {e}\n")));
+        }
+        for start in &mut reread.command_starts {
+            start.0 += offset;
+        }
+        reread.source = Some(source);
+        let reread = Box::new(reread);
+        if let Some(reader) = self.line_reader.as_mut() {
+            reader.retarget(view.get(), &reread);
+        }
+        *view = ScriptView::Reread(reread);
+        *index = 0;
+        *parsed_with = now;
+        Ok(())
+    }
+
+    /// Bookkeeping before command `index` of a script body runs: a
+    /// `(( ))`/`[[ ]]` there takes `$LINENO` from where it starts (the AST
+    /// node has no span), and under `set -v` a shell's top level echoes the
+    /// source lines read for it (bash prints each line as it reads it).
+    #[inline(never)]
+    fn before_body_command(
+        &mut self,
+        script: &Script,
+        index: usize,
+        command: &Command,
+        top_level: bool,
+    ) -> Option<crate::StreamData> {
+        let start = script.command_starts.get(index).copied();
+        if let Some((_, line)) = start
+            && matches!(
+                command,
+                Command::Compound(
+                    CompoundCommand::Arithmetic(_) | CompoundCommand::Conditional(_),
+                    _
+                )
+            )
+        {
+            self.current_line = self.line_at(line);
+        }
+        if !top_level || !self.flags.contains(BashFlags::VERBOSE) {
+            return None;
+        }
+        let (_, line) = start?;
+        let source = script.source.as_deref()?;
+        let prev_end = index
+            .checked_sub(1)
+            .and_then(|i| script.command_end_lines.get(i).copied())
+            .unwrap_or(0);
+        if line <= prev_end {
+            return None;
+        }
+        let end = script.command_end_lines.get(index).copied().unwrap_or(line);
+        // A re-read rest starts over at index 0: begin at its own line.
+        let first = if index == 0 { line } else { prev_end + 1 };
+        let mut text = String::new();
+        for (n, l) in source.split_inclusive('\n').enumerate() {
+            let n = n + 1;
+            if n > end {
+                break;
+            }
+            if n >= first {
+                text.push_str(l);
+            }
+        }
+        if !text.is_empty() && !text.ends_with('\n') {
+            text.push('\n');
+        }
+        (!text.is_empty()).then(|| text.into())
+    }
+
+    /// Emit `set -v` echoed lines as the shell's own stderr: through any
+    /// `exec 2>...` target, merged into stdout when fd 2 joins fd 1.
+    /// Boxed so the script body loop's frame stays small (TM-DOS-089).
+    #[inline(never)]
+    fn route_verbose_echo(
+        &mut self,
+        echo: crate::StreamData,
+    ) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<ExecResult>> + Send + '_>> {
+        Box::pin(async move {
+            let mut result = ExecResult {
+                stderr: echo,
+                ..ExecResult::default()
+            };
+            let emitted = (
+                self.output_stream_stdout_bytes,
+                self.output_stream_stderr_bytes,
+            );
+            self.route_exec_output(&mut result, emitted, (0, 0), None)
+                .await?;
+            if self.merge_stderr {
+                Self::merge_stderr_into_stdout(&mut result);
+            }
+            let emit_before = self.output_emit_count;
+            self.maybe_emit_output(&result.stdout, &result.stderr, emit_before);
+            self.flush_exec_passthrough(&mut result);
+            Ok(result)
+        })
+    }
+
+    /// Parse shell text (a trap, `$(...)` in arithmetic, a sourced script)
+    /// under the shell's limits, budget and alias/extglob options. Kept out
+    /// of line so the async callers' frames hold no `Parser` (TM-DOS-089).
+    #[inline(never)]
+    fn parse_shell_text(&self, text: &str) -> Result<Script> {
+        Parser::with_limits(
+            text,
+            self.limits.max_ast_depth,
+            self.limits.max_parser_operations,
+        )
+        .with_execution_budget(self.execution_budget.clone())
+        .with_options(self.parse_options())
+        .parse()
+    }
+
     async fn execute_script_body(
         &mut self,
         script: &Script,
@@ -3874,7 +4072,21 @@ impl Interpreter {
         let mut aborted_line: Option<usize> = None;
         let mut propagate_abort = false;
         let mut propagated_flow = ControlFlow::None;
-        for (index, command) in script.commands.iter().enumerate() {
+        // The script being run: as parsed, or its rest re-read after an
+        // `alias`/`shopt -s extglob` changed how the next lines parse.
+        let mut view = ScriptView::Parsed(script);
+        let mut parsed_with = Box::new(self.parse_options());
+        let mut next_index = 0;
+        loop {
+            if next_index > 0 {
+                self.reread_script_rest(&mut view, &mut next_index, &mut parsed_with)?;
+            }
+            let script = view.get();
+            let Some(command) = script.commands.get(next_index) else {
+                break;
+            };
+            let index = next_index;
+            next_index += 1;
             if aborted_line == Some(Self::command_start_line(command)) {
                 continue;
             }
@@ -3888,6 +4100,11 @@ impl Interpreter {
                 stderr.append(&err);
             }
             self.check_cancelled()?;
+            if let Some(echo) = self.before_body_command(script, index, command, run_exit_trap) {
+                let echo = self.route_verbose_echo(echo).await?;
+                stdout.append(&echo.stdout);
+                stderr.append(&echo.stderr);
+            }
             let emit_before = self.output_emit_count;
             let emitted_before = (
                 self.output_stream_stdout_bytes,
@@ -4053,7 +4270,7 @@ impl Interpreter {
             && self
                 .line_reader
                 .as_ref()
-                .is_some_and(|r| r.interactive && r.reads(script))
+                .is_some_and(|r| r.interactive && r.reads(view.get()))
         {
             let (out, err) = self.top_level_line_async(true).await;
             stdout.append(&out);
@@ -4062,7 +4279,7 @@ impl Interpreter {
 
         // Syntax error after the commands that ran: bash reads and runs a
         // script line by line, so it reports the error only on reaching it.
-        if !stopped && let Some(message) = &script.trailing_error {
+        if !stopped && let Some(message) = &view.get().trailing_error {
             let emit_before = self.output_emit_count;
             let err = crate::StreamData::from(message.clone());
             self.maybe_emit_output(&crate::StreamData::new(), &err, emit_before);
@@ -4078,14 +4295,7 @@ impl Interpreter {
         if run_exit_trap {
             if let Some(trap_cmd) = self.scoped.traps.get("EXIT").cloned() {
                 // THREAT[TM-DOS-030]: Propagate interpreter parser limits
-                if let Ok(trap_script) = Parser::with_limits(
-                    &trap_cmd,
-                    self.limits.max_ast_depth,
-                    self.limits.max_parser_operations,
-                )
-                .with_execution_budget(self.execution_budget.clone())
-                .parse()
-                {
+                if let Ok(trap_script) = self.parse_shell_text(&trap_cmd) {
                     let emit_before = self.output_emit_count;
                     if let Ok(trap_result) =
                         self.execute_command_sequence(&trap_script.commands).await
@@ -4324,12 +4534,26 @@ impl Interpreter {
                     result
                 }
                 Command::Pipeline(pipeline) if pipeline.negated => {
-                    // `! cmd` is an errexit-ignored context, inside too.
-                    self.condition_sequence_depth += 1;
+                    // `! cmd` is an errexit-ignored context, inside too. bash
+                    // does it by clearing `set -e` for the pipeline, so a
+                    // `set -e` run inside (`f() { set -e; false; }; ! f`)
+                    // is live again.
+                    let ignore = usize::from(self.is_errexit_enabled());
+                    self.condition_sequence_depth += ignore;
+                    self.errexit_fired = false;
                     let result = self.execute_pipeline(pipeline).await;
-                    self.condition_sequence_depth -= 1;
+                    self.condition_sequence_depth -= ignore;
+                    // Still on afterwards: not a subshell's own `set -e`.
+                    let fired = std::mem::take(&mut self.errexit_fired)
+                        && ignore == 0
+                        && self.is_errexit_enabled();
                     result.map(|mut r| {
                         r.errexit_suppressed = true;
+                        if fired {
+                            // The failure that stopped the body ends the shell.
+                            r.control_flow = ControlFlow::Exit(1 - r.exit_code.min(1));
+                            r.exit_code = 1 - r.exit_code.min(1);
+                        }
                         r
                     })
                 }
@@ -4655,14 +4879,7 @@ impl Interpreter {
                     let parent_had_same = snap.scoped.traps.get("EXIT") == Some(&trap_cmd);
                     if !parent_had_same {
                         // THREAT[TM-DOS-030]: Propagate interpreter parser limits
-                        if let Ok(trap_script) = Parser::with_limits(
-                            &trap_cmd,
-                            self.limits.max_ast_depth,
-                            self.limits.max_parser_operations,
-                        )
-                        .with_execution_budget(self.execution_budget.clone())
-                        .parse()
-                        {
+                        if let Ok(trap_script) = self.parse_shell_text(&trap_cmd) {
                             let emit_before = self.output_emit_count;
                             if let Ok(ref mut res) = result
                                 && let Ok(trap_result) =
@@ -5473,6 +5690,20 @@ impl Interpreter {
         })
     }
 
+    /// `[[ s =~ ~/x ]]`: the directory a tilde expands to matches
+    /// literally, as quoted text does (bash quotes tilde results).
+    async fn tilde_regex_operand(&mut self, word: &Word) -> Result<String> {
+        let [WordPart::Literal(lit)] = word.parts.as_slice() else {
+            return self.expand_word(word).await;
+        };
+        let (prefix, rest) = lit.split_at(lit.find('/').unwrap_or(lit.len()));
+        let dir = self.expand_word(&Word::literal(prefix)).await?;
+        if dir == prefix {
+            return self.expand_word(word).await;
+        }
+        Ok(format!("{}{rest}", regex::escape(&dir)))
+    }
+
     /// A `[[ ]]` word list with no `!`, `&&`, `||` or wrapping parens on top.
     fn conditional_words_leaf(words: &[Word]) -> bool {
         !words.is_empty()
@@ -5501,8 +5732,14 @@ impl Interpreter {
                         words[i - 1].parts.as_slice(),
                         [WordPart::Literal(op)] if matches!(op.as_str(), "==" | "=" | "!=")
                     );
+                let tilde_regex = i > 0
+                    && Self::conditional_word_literal(&words[i - 1]) == Some("=~")
+                    && !word.quoted
+                    && matches!(word.parts.as_slice(), [WordPart::Literal(l)] if l.starts_with('~'));
                 expanded.push(if is_pattern {
                     self.expand_pattern_word(word).await?
+                } else if tilde_regex {
+                    Box::pin(self.tilde_regex_operand(word)).await?
                 } else {
                     self.expand_word(word).await?
                 });
@@ -5776,19 +6013,24 @@ impl Interpreter {
             let prefix = self.xtrace_prefix().await;
             self.queue_xtrace_line(&prefix, &format!("(( {raw} ))"));
         }
-        match self.try_evaluate_arithmetic_with_assign(&expr) {
-            Ok(v) => Ok(ExecResult {
+        // `$(...)` stderr belongs to this command, so `(( ... )) 2>f`
+        // redirects it (as `[[ ]]` does).
+        let subst_stderr = std::mem::take(&mut self.subst_stderr);
+        let mut result = match self.try_evaluate_arithmetic_with_assign(&expr) {
+            Ok(v) => ExecResult {
                 exit_code: if v != 0 { 0 } else { 1 },
                 ..Default::default()
-            }),
+            },
             Err(_) if self.has_arith_unbound() => {
                 let msg = self.take_arith_unbound().unwrap_or_default();
-                Ok(self.expansion_error_result(msg))
+                self.expansion_error_result(msg)
             }
             // `((...))` reports an arithmetic error and fails with status 1;
             // unlike `$((...))` it does not abandon the line.
-            Err(msg) => Ok(ExecResult::err(self.arith_diag("((: ", &msg), 1)),
-        }
+            Err(msg) => ExecResult::err(self.arith_diag("((: ", &msg), 1),
+        };
+        result.stderr = subst_stderr + &result.stderr;
+        Ok(result)
     }
 
     /// A `for ((init; cond; step))` expression with its `$(...)` run, each
@@ -6435,7 +6677,8 @@ impl Interpreter {
                 max_parser_operations,
                 Some(parser_timeout),
             )
-            .with_execution_budget(self.execution_budget.clone());
+            .with_execution_budget(self.execution_budget.clone())
+            .with_options(self.parse_options());
             match nested_partial_parse(parser.parse_recovering(), noexec, &who, &script_content) {
                 Ok(s) => s,
                 Err(e) => {
@@ -6453,11 +6696,13 @@ impl Interpreter {
         let script = {
             let script_owned = script_content.clone();
             let execution_budget = self.execution_budget.clone();
+            let options = self.parse_options();
             let parse_result = tokio::time::timeout(parser_timeout, async move {
                 tokio::task::spawn_blocking(move || {
                     let parser =
                         Parser::with_limits(&script_owned, max_ast_depth, max_parser_operations)
-                            .with_execution_budget(execution_budget);
+                            .with_execution_budget(execution_budget)
+                            .with_options(options);
                     parser.parse_recovering()
                 })
                 .await
@@ -7214,6 +7459,7 @@ impl Interpreter {
             // result.errexit_suppressed (e.g. AND-OR lists).
             let suppress = result.errexit_suppressed;
             if check_errexit && self.errexit_active() && exit_code != 0 && !suppress {
+                self.errexit_fired = true;
                 return Ok(ExecResult {
                     stdout,
                     stderr,
@@ -8086,6 +8332,15 @@ impl Interpreter {
             let mut stderr = String::new();
             self.temp_path = has_command && assignments.iter().any(|a| a.name == "PATH");
             for assignment in assignments {
+                // `a[1]=x cmd`: bash refuses an element as a temporary
+                // binding, without expanding its value, and runs `cmd`.
+                if has_command && let Some(index) = &assignment.index {
+                    stderr.push_str(&self.diag(format!(
+                        "`{}[{index}]': not a valid identifier\n",
+                        assignment.name
+                    )));
+                    continue;
+                }
                 match &assignment.value {
                     AssignmentValue::Scalar(word) => {
                         let word = self.tilde_assignment_value(word);
@@ -8235,132 +8490,6 @@ impl Interpreter {
         lhs
     }
 
-    /// Try alias expansion. Returns `Some(result)` if alias was expanded, `None` otherwise.
-    async fn try_alias_expansion(
-        &mut self,
-        name: &str,
-        command: &SimpleCommand,
-        stdin: Option<crate::StreamData>,
-        var_saves: Vec<(String, Option<String>)>,
-    ) -> Option<Result<ExecResult>> {
-        let is_plain_literal = !command.name.quoted
-            && command
-                .name
-                .parts
-                .iter()
-                .all(|p| matches!(p, WordPart::Literal(_)));
-        if !is_plain_literal
-            || !self.is_expand_aliases_enabled()
-            || self.expanding_aliases.contains(name)
-        {
-            return None;
-        }
-        let expansion = self.scoped.aliases.get(name).cloned()?;
-
-        // Restore variable saves before re-executing
-        for (vname, old) in var_saves.into_iter().rev() {
-            match old {
-                Some(v) => {
-                    self.insert_variable_checked(vname, v);
-                }
-                None => {
-                    self.vars_mut().remove(&vname);
-                }
-            }
-        }
-
-        // Build expanded command: prefix assignments (`FOO=1 al`), alias
-        // value, original args.
-        let mut expanded_cmd = String::new();
-        for assignment in &command.assignments {
-            expanded_cmd.push_str(&Self::xtrace_assignment_lhs(assignment));
-            expanded_cmd.push('=');
-            match &assignment.value {
-                AssignmentValue::Scalar(w) => {
-                    expanded_cmd.push_str(&Self::format_word_for_alias_reparse(w));
-                }
-                AssignmentValue::Array(elems) => {
-                    expanded_cmd.push('(');
-                    let elems: Vec<String> = elems
-                        .iter()
-                        .map(Self::format_word_for_alias_reparse)
-                        .collect();
-                    expanded_cmd.push_str(&elems.join(" "));
-                    expanded_cmd.push(')');
-                }
-            }
-            expanded_cmd.push(' ');
-        }
-        expanded_cmd.push_str(&expansion);
-        // A value ending in a blank alias-expands the next word too, and so
-        // on down the chain (`e_ one two` with `one='ONE '`).
-        let mut trailing_space = expansion.ends_with(' ');
-        for word in &command.args {
-            let arg_str = Self::format_word_for_alias_reparse(word);
-            let plain =
-                !word.quoted && word.parts.iter().all(|p| matches!(p, WordPart::Literal(_)));
-            if trailing_space
-                && plain
-                && let Some(arg_expansion) = self.scoped.aliases.get(&arg_str)
-            {
-                trailing_space = arg_expansion.ends_with(' ');
-                expanded_cmd.push_str(arg_expansion);
-                continue;
-            }
-            if !trailing_space {
-                expanded_cmd.push(' ');
-            }
-            trailing_space = false;
-            expanded_cmd.push_str(&arg_str);
-        }
-        for redir in &command.redirects {
-            expanded_cmd.push(' ');
-            expanded_cmd.push_str(&Self::format_redirect(redir));
-        }
-
-        self.expanding_aliases.insert(name.to_string());
-
-        let prev_pipeline_stdin = self.pipeline_stdin.take();
-        if stdin.is_some() {
-            self.pipeline_stdin = stdin;
-        }
-
-        // THREAT[TM-DOS-030]: Propagate interpreter parser limits
-        let parser = Parser::with_limits(
-            &expanded_cmd,
-            self.limits.max_ast_depth,
-            self.limits.max_parser_operations,
-        )
-        .with_execution_budget(self.execution_budget.clone());
-        let result = match parser.parse() {
-            Ok(s) => {
-                // THREAT[TM-DOS-031]: Validate budget on expanded alias AST
-                // to prevent bypassing static budget checks via alias expansion.
-                if let Err(e) = crate::parser::validate_budget(&s, &self.limits) {
-                    Ok(ExecResult::err(
-                        self.diag(format!("alias expansion: budget validation failed: {e}\n")),
-                        1,
-                    ))
-                } else {
-                    // Alias expansion runs in the current shell: use
-                    // execute_script_body (like source/eval), NOT execute(),
-                    // so an aliased command does not fire the EXIT trap.
-                    self.execute_script_body(&s, false, true).await
-                }
-            }
-            // A syntax error in the expanded text fails like any syntax
-            // error: status 2.
-            Err(e) => Ok(ExecResult::err(
-                self.diag(format!("alias expansion: parse error: {e}\n")),
-                2,
-            )),
-        };
-
-        self.pipeline_stdin = prev_pipeline_stdin;
-        self.expanding_aliases.remove(name);
-        Some(result)
-    }
-
     /// Where the current simple command's process substitutions start.
     fn proc_sub_mark(&self) -> ProcSubMark {
         ProcSubMark {
@@ -8726,20 +8855,7 @@ impl Interpreter {
                 return Err(err);
             }
 
-            // Alias expansion. Boxed and gated on a defined alias so its
-            // re-parse state stays off this hot frame (TM-DOS-089).
-            if self.scoped.aliases.contains_key(&name)
-                && let Some(result) = Box::pin(self.try_alias_expansion(
-                    &name,
-                    command,
-                    stdin.clone(),
-                    var_saves.clone(),
-                ))
-                .await
-            {
-                self.discard_deferred_proc_subs_from(deferred_proc_sub_start);
-                return result;
-            }
+            // Aliases expand when the command is parsed (see `ParseOptions`).
 
             // Empty command handling
             if name.is_empty() {
@@ -8817,7 +8933,16 @@ impl Interpreter {
                 self.restore_variables(var_saves);
                 self.discard_deferred_proc_subs_from(deferred_proc_sub_start);
                 let result = ExecResult::err(err_msg, 1);
-                return self.apply_redirections(result, &command.redirects).await;
+                // failglob abandons the rest of the line (bash DISCARD):
+                // `echo *.ZZ; echo next` prints nothing more.
+                let mut result = self.apply_redirections(result, &command.redirects).await?;
+                // Under `set -e` the failed command ends the shell.
+                result.control_flow = if self.errexit_active() {
+                    ControlFlow::Exit(1)
+                } else {
+                    ControlFlow::Abort
+                };
+                return Ok(result);
             }
 
             if self.is_xtrace_enabled() {
@@ -10342,13 +10467,7 @@ impl Interpreter {
         };
 
         self.execution_budget.consume_input(script_text.len())?;
-        let parser = Parser::with_limits(
-            script_text,
-            self.limits.max_ast_depth,
-            self.limits.max_parser_operations,
-        )
-        .with_execution_budget(self.execution_budget.clone());
-        let script = match parser.parse() {
+        let script = match self.parse_shell_text(script_text) {
             Ok(s) => s,
             Err(e) => {
                 return Ok(ExecResult::err(self.diag(format!("{name}: {e}\n")), 2));
@@ -10804,13 +10923,7 @@ impl Interpreter {
 
         #[cfg(target_family = "wasm")]
         {
-            Parser::with_limits(
-                input,
-                self.limits.max_ast_depth,
-                self.limits.max_parser_operations,
-            )
-            .with_execution_budget(self.execution_budget.clone())
-            .parse()
+            self.parse_shell_text(input)
         }
 
         #[cfg(not(target_family = "wasm"))]
@@ -10820,11 +10933,13 @@ impl Interpreter {
             let max_ops = self.limits.max_parser_operations;
             let timeout = self.limits.parser_timeout;
             let execution_budget = self.execution_budget.clone();
+            let options = self.parse_options();
 
             let parse_result = tokio::time::timeout(timeout, async move {
                 tokio::task::spawn_blocking(move || {
                     let parser = Parser::with_limits(&input_owned, max_depth, max_ops)
-                        .with_execution_budget(execution_budget);
+                        .with_execution_budget(execution_budget)
+                        .with_options(options);
                     parser.parse()
                 })
                 .await
@@ -10844,6 +10959,16 @@ impl Interpreter {
         }
     }
 
+    /// Shell state that changes how text parses: the alias table (when
+    /// `expand_aliases` is on) and `extglob`.
+    pub(crate) fn parse_options(&self) -> crate::parser::ParseOptions {
+        crate::parser::ParseOptions {
+            aliases: (self.is_expand_aliases_enabled() && !self.scoped.aliases.is_empty())
+                .then(|| self.scoped.aliases.clone()),
+            extglob: self.is_extglob(),
+        }
+    }
+
     /// Check if expand_aliases is enabled via shopt.
     fn is_expand_aliases_enabled(&self) -> bool {
         self.scoped
@@ -10853,224 +10978,6 @@ impl Interpreter {
             .unwrap_or(false)
     }
 
-    /// Format a Redirect back to its textual representation for alias expansion.
-    fn format_redirect(redir: &Redirect) -> String {
-        let fd_prefix = match &redir.fd_var {
-            Some(var) => format!("{{{var}}}"),
-            None => redir.fd.map(|fd| fd.to_string()).unwrap_or_default(),
-        };
-        let op = match redir.kind {
-            RedirectKind::Output => ">",
-            RedirectKind::Append => ">>",
-            RedirectKind::Input => "<",
-            RedirectKind::HereDoc => "<<",
-            RedirectKind::HereDocStrip => "<<-",
-            RedirectKind::HereString => "<<<",
-            RedirectKind::Clobber => ">|",
-            RedirectKind::DupOutput => ">&",
-            RedirectKind::DupInput => "<&",
-            RedirectKind::OutputBoth => "&>",
-            RedirectKind::ReadWrite => "<>",
-        };
-        format!(
-            "{}{}{}",
-            fd_prefix,
-            op,
-            Self::format_word_for_alias_reparse(&redir.target)
-        )
-    }
-
-    /// Serialize a parsed word for alias re-parse without dropping quoted literalness.
-    fn format_word_for_alias_reparse(word: &Word) -> String {
-        if !word.quoted {
-            return format!("{}", word);
-        }
-
-        if word.has_unquoted_glob {
-            // Keep glob metacharacters outside quotes while quoting expansions.
-            // Wrapping the whole word would erase the QuotedGlobWord boundary.
-            let mut out = String::new();
-            for part in &word.parts {
-                match part {
-                    WordPart::Literal(s) => Self::push_alias_reparse_literal(&mut out, s, true),
-                    _ => {
-                        out.push('"');
-                        Self::push_alias_reparse_word_part(&mut out, part);
-                        out.push('"');
-                    }
-                }
-            }
-            return out;
-        }
-
-        let mut out = String::from("\"");
-        for part in &word.parts {
-            Self::push_alias_reparse_word_part(&mut out, part);
-        }
-        out.push('"');
-        out
-    }
-
-    fn push_alias_reparse_literal(out: &mut String, s: &str, preserve_glob: bool) {
-        for ch in s.chars() {
-            if preserve_glob && matches!(ch, '*' | '?' | '[' | ']') {
-                out.push(ch);
-                continue;
-            }
-            if preserve_glob {
-                match ch {
-                    'a'..='z'
-                    | 'A'..='Z'
-                    | '0'..='9'
-                    | '_'
-                    | '-'
-                    | '.'
-                    | '/'
-                    | ':'
-                    | ','
-                    | '+'
-                    | '='
-                    | '%'
-                    | '@' => out.push(ch),
-                    _ => {
-                        out.push('\\');
-                        out.push(ch);
-                    }
-                }
-            } else {
-                if matches!(ch, '\\' | '"' | '$' | '`') {
-                    out.push('\\');
-                }
-                out.push(ch);
-            }
-        }
-    }
-
-    fn push_alias_reparse_word_part(out: &mut String, part: &WordPart) {
-        match part {
-            WordPart::CompoundAssignment { .. } => {
-                let word = Word {
-                    parts: vec![part.clone()],
-                    quoted: false,
-                    has_unquoted_glob: false,
-                    part_quoted: Vec::new(),
-                    raw: None,
-                };
-                out.push_str(&word.to_string());
-            }
-            WordPart::Literal(s) => Self::push_alias_reparse_literal(out, s, false),
-            WordPart::BadSubstitution(text) => out.push_str(text),
-            WordPart::Variable(name) => out.push_str(&format!("${}", name)),
-            WordPart::CommandSubstitution(cmd) => out.push_str(&format!("$({:?})", cmd)),
-            WordPart::ArithmeticExpansion(expr) => out.push_str(&format!("$(({}))", expr)),
-            WordPart::ParameterExpansion {
-                name,
-                operator,
-                operand,
-                colon_variant,
-            } => match operator {
-                ParameterOp::UseDefault => {
-                    let c = if *colon_variant { ":" } else { "" };
-                    out.push_str(&format!("${{{}{}-{}}}", name, c, operand));
-                }
-                ParameterOp::AssignDefault => {
-                    let c = if *colon_variant { ":" } else { "" };
-                    out.push_str(&format!("${{{}{}={}}}", name, c, operand));
-                }
-                ParameterOp::UseReplacement => {
-                    let c = if *colon_variant { ":" } else { "" };
-                    out.push_str(&format!("${{{}{}+{}}}", name, c, operand));
-                }
-                ParameterOp::Error => {
-                    let c = if *colon_variant { ":" } else { "" };
-                    out.push_str(&format!("${{{}{}?{}}}", name, c, operand));
-                }
-                ParameterOp::RemovePrefixShort => {
-                    out.push_str(&format!("${{{}#{}}}", name, operand))
-                }
-                ParameterOp::RemovePrefixLong => {
-                    out.push_str(&format!("${{{}##{}}}", name, operand))
-                }
-                ParameterOp::RemoveSuffixShort => {
-                    out.push_str(&format!("${{{}%{}}}", name, operand))
-                }
-                ParameterOp::RemoveSuffixLong => {
-                    out.push_str(&format!("${{{}%%{}}}", name, operand))
-                }
-                ParameterOp::ReplaceFirst {
-                    pattern,
-                    replacement,
-                } => out.push_str(&format!("${{{}/{}/{}}}", name, pattern, replacement)),
-                ParameterOp::ReplaceAll {
-                    pattern,
-                    replacement,
-                } => out.push_str(&format!("${{{}//{}/{}}}", name, pattern, replacement)),
-                ParameterOp::UpperFirst => out.push_str(&format!("${{{}^{}}}", name, operand)),
-                ParameterOp::UpperAll => out.push_str(&format!("${{{}^^{}}}", name, operand)),
-                ParameterOp::LowerFirst => out.push_str(&format!("${{{},{}}}", name, operand)),
-                ParameterOp::LowerAll => out.push_str(&format!("${{{},,{}}}", name, operand)),
-                ParameterOp::ToggleFirst => out.push_str(&format!("${{{}~{}}}", name, operand)),
-                ParameterOp::ToggleAll => out.push_str(&format!("${{{}~~{}}}", name, operand)),
-            },
-            WordPart::Length(name) => out.push_str(&format!("${{#{}}}", name)),
-            WordPart::ArrayAccess { name, index } => {
-                out.push_str(&format!("${{{}[{}]}}", name, index))
-            }
-            WordPart::ArrayLength(name) => out.push_str(&format!("${{#{}[@]}}", name)),
-            WordPart::ArrayIndices { name, star } => out.push_str(&format!(
-                "${{!{}[{}]}}",
-                name,
-                if *star { '*' } else { '@' }
-            )),
-            WordPart::Substring {
-                name,
-                offset,
-                length,
-            } => {
-                if let Some(len) = length {
-                    out.push_str(&format!("${{{}:{}:{}}}", name, offset, len));
-                } else {
-                    out.push_str(&format!("${{{}:{}}}", name, offset));
-                }
-            }
-            WordPart::IndirectExpansion {
-                name,
-                operator,
-                operand,
-                colon_variant,
-            } => {
-                if let Some(op) = operator {
-                    let c = if *colon_variant { ":" } else { "" };
-                    let op_char = match op {
-                        ParameterOp::UseDefault => "-",
-                        ParameterOp::AssignDefault => "=",
-                        ParameterOp::UseReplacement => "+",
-                        ParameterOp::Error => "?",
-                        _ => "",
-                    };
-                    out.push_str(&format!("${{!{}{}{}{}}}", name, c, op_char, operand));
-                } else {
-                    out.push_str(&format!("${{!{}}}", name));
-                }
-            }
-            WordPart::IndirectSuffix { name, suffix } => {
-                out.push_str(&format!("${{!{name}{suffix}}}"))
-            }
-            WordPart::PrefixMatch { prefix, star } => out.push_str(&format!(
-                "${{!{}{}}}",
-                prefix,
-                if *star { '*' } else { '@' }
-            )),
-            WordPart::ProcessSubstitution { commands, is_input } => {
-                let prefix = if *is_input { "<" } else { ">" };
-                out.push_str(&format!("{}({:?})", prefix, commands));
-            }
-            WordPart::Transformation { name, operator } => {
-                out.push_str(&format!("${{{}@{}}}", name, operator));
-            }
-        }
-    }
-
     fn shadow_local_array_bindings(&mut self, name: &str, keep_indexed: bool, keep_assoc: bool) {
         // A newly retained snapshot keeps the removed binding's entries charged
         // (released at frame pop). When no new snapshot is retained — a second
@@ -12949,13 +12856,7 @@ impl Interpreter {
             // Fire EXIT trap set inside the command substitution
             if let Some(trap_cmd) = self.scoped.traps.get("EXIT").cloned()
                 && snapshot.scoped.traps.get("EXIT") != Some(&trap_cmd)
-                && let Ok(trap_script) = Parser::with_limits(
-                    &trap_cmd,
-                    self.limits.max_ast_depth,
-                    self.limits.max_parser_operations,
-                )
-                .with_execution_budget(self.execution_budget.clone())
-                .parse()
+                && let Ok(trap_script) = self.parse_shell_text(&trap_cmd)
                 && let Ok(trap_result) = self
                     .execute_capture_only_sequence(&trap_script.commands)
                     .await
@@ -13024,6 +12925,18 @@ impl Interpreter {
         let lookup = |name: &str| -> String {
             if plain {
                 self.scoped.variables.get(name).cloned().unwrap_or_default()
+            } else if let Some(arr) = name
+                .strip_suffix("[@]")
+                .or_else(|| name.strip_suffix("[*]"))
+            {
+                // `assoc["${array[@]}"]`: the elements joined (bash, without
+                // strict_array).
+                let sep = if name.ends_with("[*]") {
+                    self.get_ifs_separator()
+                } else {
+                    " ".to_string()
+                };
+                self.array_values(self.resolve_nameref(arr)).join(&sep)
             } else {
                 self.resolve_param_expansion_name(name).1
             }
@@ -13991,13 +13904,7 @@ impl Interpreter {
                         _ => cmd.push(c),
                     }
                 }
-                let parser = Parser::with_limits(
-                    &cmd,
-                    self.limits.max_ast_depth,
-                    self.limits.max_parser_operations,
-                )
-                .with_execution_budget(self.execution_budget.clone());
-                let out = match parser.parse() {
+                let out = match self.parse_shell_text(&cmd) {
                     Ok(script) if self.counters.push_subst(&self.limits).is_ok() => {
                         self.execute_cmd_subst(&script.commands).await?
                     }
@@ -14034,13 +13941,7 @@ impl Interpreter {
                 }
                 // Execute the command and substitute in a subshell context:
                 // save/restore mutable state so mutations don't leak.
-                let parser = Parser::with_limits(
-                    &cmd,
-                    self.limits.max_ast_depth,
-                    self.limits.max_parser_operations,
-                )
-                .with_execution_budget(self.execution_budget.clone());
-                match parser.parse() {
+                match self.parse_shell_text(&cmd) {
                     Ok(script) => {
                         if self.counters.push_subst(&self.limits).is_err() {
                             result.push('0');
@@ -14405,13 +14306,7 @@ impl Interpreter {
         stderr: &mut crate::StreamData,
     ) -> Option<(ControlFlow, i32)> {
         // THREAT[TM-DOS-030]: Propagate interpreter parser limits.
-        let Ok(trap_script) = Parser::with_limits(
-            trap_cmd,
-            self.limits.max_ast_depth,
-            self.limits.max_parser_operations,
-        )
-        .with_execution_budget(self.execution_budget.clone())
-        .parse() else {
+        let Ok(trap_script) = self.parse_shell_text(trap_cmd) else {
             return None;
         };
         let was_in_trap = self.in_trap;
@@ -17448,8 +17343,10 @@ echo "count=$COUNT"
 
     #[tokio::test]
     async fn test_output_process_sub_cleared_after_failglob_in_same_exec() {
+        // failglob abandons the rest of its line, as in bash: VICTIM goes on
+        // the next one.
         let result =
-            run_script(r#"shopt -s failglob; echo >(echo STALE) ./missing_*; echo VICTIM"#).await;
+            run_script("shopt -s failglob; echo >(echo STALE) ./missing_*\necho VICTIM").await;
         assert!(
             !result.stdout.contains("STALE"),
             "deferred output process substitution leaked after failglob"
diff --git a/crates/bashkit/src/interpreter/redirection.rs b/crates/bashkit/src/interpreter/redirection.rs
index bedaac429..2b1528db3 100644
--- a/crates/bashkit/src/interpreter/redirection.rs
+++ b/crates/bashkit/src/interpreter/redirection.rs
@@ -23,7 +23,8 @@ use crate::error::io_error_reason;
 
 /// A redirect target that brace expansion, word splitting or pathname
 /// expansion could turn into other than one word (`> $f`, `> out-*`,
-/// `> a-{1,2}`). Plain and quoted words skip the field pass.
+/// `> a-{1,2}`), or one with a quoted expansion. Plain words skip the
+/// field pass.
 fn redirect_target_may_split(redirect: &Redirect) -> bool {
     if !matches!(
         redirect.kind,
@@ -41,7 +42,13 @@ fn redirect_target_may_split(redirect: &Redirect) -> bool {
     }
     let word = &redirect.target;
     if word.quoted && !word.has_unquoted_glob {
-        return false;
+        // Quoted expansions resolve up front too: `"$@"` may still give
+        // several words (ambiguous), and a compound's or function's target
+        // expands before its body runs (`f() {..} >"f$((i++))"`).
+        return word
+            .parts
+            .iter()
+            .any(|p| !matches!(p, WordPart::Literal(_)));
     }
     word.parts.iter().any(|part| match part {
         WordPart::Literal(text) => text.contains(['*', '?', '[', '{', '(', '\\']),
diff --git a/crates/bashkit/src/lib.rs b/crates/bashkit/src/lib.rs
index 712fbcce5..3e344a711 100644
--- a/crates/bashkit/src/lib.rs
+++ b/crates/bashkit/src/lib.rs
@@ -1051,6 +1051,8 @@ impl Bash {
         }
 
         let parser_timeout = self.parser_timeout;
+        // Aliases and extglob from earlier calls shape this parse.
+        let parse_options = self.interpreter.parse_options();
         let max_ast_depth = self.max_ast_depth;
         let max_parser_operations = self.max_parser_operations;
 
@@ -1092,7 +1094,8 @@ impl Bash {
                 max_parser_operations,
                 Some(parser_timeout),
             )
-            .with_execution_budget(self.interpreter.execution_budget().clone());
+            .with_execution_budget(self.interpreter.execution_budget().clone())
+            .with_options(parse_options.clone());
             recover_partial_parse(parser.parse_recovering(), &syntax_who, script)?
         };
 
@@ -1102,7 +1105,8 @@ impl Bash {
         #[cfg(not(target_family = "wasm"))]
         let ast = if input_len <= SPAWN_BLOCKING_THRESHOLD {
             let parser = Parser::with_limits(script, max_ast_depth, max_parser_operations)
-                .with_execution_budget(self.interpreter.execution_budget().clone());
+                .with_execution_budget(self.interpreter.execution_budget().clone())
+                .with_options(parse_options.clone());
             match recover_partial_parse(parser.parse_recovering(), &syntax_who, script) {
                 Ok(ast) => {
                     #[cfg(feature = "logging")]
@@ -1119,11 +1123,13 @@ impl Bash {
             let script_owned = script.to_owned();
             let execution_budget = self.interpreter.execution_budget().clone();
             let who = syntax_who.clone();
+            let parse_options = parse_options.clone();
             let parse_result = tokio::time::timeout(parser_timeout, async {
                 tokio::task::spawn_blocking(move || {
                     let parser =
                         Parser::with_limits(&script_owned, max_ast_depth, max_parser_operations)
-                            .with_execution_budget(execution_budget);
+                            .with_execution_budget(execution_budget)
+                            .with_options(parse_options);
                     recover_partial_parse(parser.parse_recovering(), &who, &script_owned)
                 })
                 .await
diff --git a/crates/bashkit/src/parser/ast.rs b/crates/bashkit/src/parser/ast.rs
index 2fff60509..5037beb8b 100644
--- a/crates/bashkit/src/parser/ast.rs
+++ b/crates/bashkit/src/parser/ast.rs
@@ -25,6 +25,17 @@ pub struct Script {
     /// reading it. Empty when the script was not built by the parser.
     #[serde(default, skip_serializing_if = "Vec::is_empty")]
     pub command_end_lines: Vec<usize>,
+    /// Text the script was parsed from. The interpreter re-reads the rest
+    /// from a later top-level command when `alias` or `shopt -s extglob`
+    /// changed how it parses (bash parses a line at a time). Never
+    /// serialized.
+    #[serde(skip)]
+    pub source: Option<std::sync::Arc<str>>,
+    /// Byte offset into `source` and line where each top-level command
+    /// starts, parallel to `commands`; after a syntax error one more entry
+    /// marks where the unparsed rest starts. Never serialized.
+    #[serde(skip)]
+    pub command_starts: Vec<(usize, usize)>,
 }
 
 /// A single command in the script.
@@ -1388,6 +1399,8 @@ mod tests {
             span: Span::new(),
             trailing_error: None,
             command_end_lines: Vec::new(),
+            source: None,
+            command_starts: Vec::new(),
         };
         assert!(script.commands.is_empty());
     }
diff --git a/crates/bashkit/src/parser/budget.rs b/crates/bashkit/src/parser/budget.rs
index a82ec992f..11e89c190 100644
--- a/crates/bashkit/src/parser/budget.rs
+++ b/crates/bashkit/src/parser/budget.rs
@@ -398,6 +398,8 @@ mod tests {
             span: Span::new(),
             trailing_error: None,
             command_end_lines: Vec::new(),
+            source: None,
+            command_starts: Vec::new(),
         };
         let limits = ExecutionLimits::default();
         let err = validate(&ast, &limits).unwrap_err();
diff --git a/crates/bashkit/src/parser/lexer.rs b/crates/bashkit/src/parser/lexer.rs
index 9e77e8cde..ad0d94cd3 100644
--- a/crates/bashkit/src/parser/lexer.rs
+++ b/crates/bashkit/src/parser/lexer.rs
@@ -15,6 +15,12 @@ pub struct SpannedToken {
     /// Source text of a word token, only while raw capture is on (function
     /// bodies, for `type`/`declare -f` printing).
     pub raw: Option<String>,
+    /// A word lexed with no quoting or escapes (only tracked while alias
+    /// expansion is on): only such a word can name an alias.
+    pub plain: bool,
+    /// The word follows an alias whose value ends in a blank, so it is
+    /// checked for alias expansion too (bash `alias e='echo '`).
+    pub after_blank_alias: bool,
 }
 
 /// Maximum nesting depth for command substitution in the lexer.
@@ -88,6 +94,22 @@ pub struct Lexer<'a> {
     /// reserved word or an assignment): `a[1 + 2]=x` keeps the blanks
     /// inside its subscript.
     spaced_subscript: bool,
+    /// Alias expansion is on: word tokens record whether they are plain.
+    track_plain: bool,
+    /// How many characters at the front of `reinject_buf` are alias text.
+    /// They do not move the source position (spans and `$LINENO` stay on
+    /// the line that named the alias).
+    alias_front: usize,
+    /// Aliases whose text is still being read: name, the `alias_front`
+    /// value under which that text is used up, and whether it ends in a blank.
+    alias_stack: Vec<(String, usize, bool)>,
+    /// A blank-ending alias was just used up: the next word is checked too.
+    blank_alias_pending: bool,
+    /// `!(` starts an extglob group. Off when the shell runs without
+    /// `shopt -s extglob`: then `!(a && b)` is `!` and a subshell. The other
+    /// groups (`@(`, `+(`, ...) always lex as patterns, where bash would
+    /// report a syntax error instead.
+    extglob_bang: bool,
 }
 
 impl<'a> Lexer<'a> {
@@ -108,6 +130,11 @@ impl<'a> Lexer<'a> {
             capture_raw: false,
             raw_buf: String::new(),
             spaced_subscript: true,
+            track_plain: false,
+            alias_front: 0,
+            alias_stack: Vec::new(),
+            blank_alias_pending: false,
+            extglob_bang: true,
         }
     }
 
@@ -141,20 +168,105 @@ impl<'a> Lexer<'a> {
     }
 
     fn advance(&mut self) -> Option<char> {
+        let mut from_alias = false;
         let ch = if !self.reinject_buf.is_empty() {
+            if self.alias_front > 0 {
+                self.alias_front -= 1;
+                from_alias = true;
+            }
             self.reinject_buf.pop_front()
         } else {
             self.chars.next()
         };
         if let Some(c) = ch {
-            self.position.advance(c);
-            if self.capture_raw {
+            if from_alias {
+                self.finish_used_aliases();
+            } else {
+                self.position.advance(c);
+            }
+            if self.capture_raw || self.track_plain {
                 self.raw_buf.push(c);
             }
         }
         ch
     }
 
+    /// Whether `!(` starts an extglob group (`shopt -s extglob`).
+    pub(crate) fn set_extglob_bang(&mut self, on: bool) {
+        self.extglob_bang = on;
+    }
+
+    pub(crate) fn extglob_bang(&self) -> bool {
+        self.extglob_bang
+    }
+
+    /// Turn on plain-word tracking (alias expansion is on).
+    pub(crate) fn set_track_plain(&mut self, on: bool) {
+        self.track_plain = on;
+    }
+
+    /// Whether alias `name` is being expanded now (its text is still being
+    /// read): bash never expands an alias inside its own text.
+    pub(crate) fn alias_active(&self, name: &str) -> bool {
+        self.alias_stack
+            .iter()
+            .any(|(n, end, _)| n == name && self.alias_front > *end)
+    }
+
+    /// Read `text`, the value of alias `name`, before the rest of the input.
+    pub(crate) fn push_alias(&mut self, name: &str, text: &str) {
+        let end = self.alias_front;
+        let blank = text.ends_with([' ', '\t']);
+        // bash checks the first word of a blank-ending value as well as the
+        // word after it (`alias eye2='eye1 '`).
+        self.blank_alias_pending |= blank;
+        let mut n = 0;
+        for ch in text.chars().rev() {
+            self.reinject_buf.push_front(ch);
+            n += 1;
+        }
+        self.alias_front += n;
+        self.alias_stack.push((name.to_string(), end, blank));
+        // An empty value is used up at once.
+        self.finish_used_aliases();
+    }
+
+    /// Pop aliases whose text is fully read; a blank-ending one makes the
+    /// next word an alias candidate.
+    fn finish_used_aliases(&mut self) {
+        while let Some((_, end, blank)) = self.alias_stack.last() {
+            if self.alias_front > *end {
+                break;
+            }
+            if *blank {
+                self.blank_alias_pending = true;
+            }
+            self.alias_stack.pop();
+        }
+    }
+
+    /// Hand back alias text not read yet (a here-document body comes from
+    /// the input, never from the alias: bash reads the rest of the alias
+    /// as commands after the body).
+    fn detach_alias_text(&mut self) -> Vec<char> {
+        let n = self.alias_front.min(self.reinject_buf.len());
+        if n == 0 {
+            return Vec::new();
+        }
+        let mut text: Vec<char> = self.reinject_buf.drain(..n).collect();
+        self.alias_front = 0;
+        self.alias_stack.clear();
+        // The rest of the input line follows the alias text too; the body
+        // starts on the next input line.
+        while let Some(ch) = self.advance() {
+            text.push(ch);
+            if ch == '\n' {
+                break;
+            }
+        }
+        text
+    }
+
     /// Upcoming characters without consuming them: re-injected text first
     /// (the rest of a heredoc line), then the input.
     fn lookahead(&self) -> Lookahead<'_, 'a> {
@@ -274,6 +386,7 @@ impl<'a> Lexer<'a> {
         self.skip_whitespace();
         let start = self.position;
         self.raw_buf.clear();
+        let after_blank_alias = std::mem::take(&mut self.blank_alias_pending);
         let token = self.next_token_inner()?;
         // A word is lexed in assignment position after an operator, a
         // reserved word or another assignment, never after a command name.
@@ -285,6 +398,7 @@ impl<'a> Lexer<'a> {
             _ => true,
         };
         let end = self.position;
+        let plain = self.track_plain && matches!(&token, Token::Word(w) if *w == self.raw_buf);
         let raw = (self.capture_raw
             && matches!(
                 token,
@@ -298,6 +412,8 @@ impl<'a> Lexer<'a> {
             token,
             span: Span::from_positions(start, end),
             raw,
+            plain,
+            after_blank_alias,
         })
     }
 
@@ -912,6 +1028,9 @@ impl<'a> Lexer<'a> {
         // quoted glob characters stay literal (see the end of this function).
         let mut quoted_ranges: Vec<(usize, usize)> = Vec::new();
         let mut has_unquoted_expansion = false;
+        // An extglob group held quoted or escaped text, kept as `\x`: the
+        // word must drop those escapes when it matches nothing.
+        let mut extglob_escaped = false;
         // A blank inside `name[...]` was checked to close with `]=` ahead.
         let mut spaced_ok = false;
 
@@ -1261,9 +1380,13 @@ impl<'a> Lexer<'a> {
                 } else {
                     word.push('\\');
                 }
-            } else if ch == '(' && word.ends_with(['@', '?', '*', '+', '!']) {
+            } else if ch == '('
+                && (word.ends_with(['@', '?', '*', '+'])
+                    || (self.extglob_bang && word.ends_with('!')))
+            {
                 // Extglob: @(...), ?(...), *(...), +(...), !(...)
                 // Consume through matching ) including nested parens
+                let group_start = word.len();
                 word.push(ch);
                 self.advance();
                 let mut depth = 1;
@@ -1320,6 +1443,7 @@ impl<'a> Lexer<'a> {
                         _ => {}
                     }
                 }
+                extglob_escaped |= word[group_start..].contains('\\');
             } else if ch == '}' {
                 // An unmatched `}` inside a word is a literal. `}` is a
                 // reserved word, not a metacharacter, so it only terminates a
@@ -1350,6 +1474,15 @@ impl<'a> Lexer<'a> {
             }
         }
 
+        // `a[` / `a[5 +` in assignment position: bash reads on for the
+        // `]` that closes the subscript and hits end of input.
+        if self.spaced_subscript
+            && Self::open_subscript_depth(&word) > 0
+            && !self.lookahead().any(|c| c == ']')
+        {
+            return Some(Token::Error("unterminated subscript".to_string()));
+        }
+
         // Quoted or escaped glob characters are literal (`a"*"`, `a\*`,
         // `a'?'`). With an unquoted glob in the same word they are escaped
         // in place, the QuotedGlobWord convention also used for words that
@@ -1359,9 +1492,19 @@ impl<'a> Lexer<'a> {
         let quoted_glob = quoted_ranges.iter().any(|&(start, end)| {
             // `(`, `)` and `|` count too: `*\(\)` must not become the
             // extglob `*()`. So does `\`: `[\\]` stays one bracket.
-            word[start..end].contains(['*', '?', '[', '{', '}', ',', '(', ')', '|', '\\'])
+            word[start..end].contains(['*', '?', '[', ']', '{', '}', ',', '(', ')', '|', '\\'])
         });
-        if quoted_glob && has_unquoted_glob {
+        // A quoted `-` only matters next to an unquoted glob, where it must
+        // stay a literal inside a bracket: `*.[C\-D]` matches `foo.-`.
+        let quoted_dash =
+            has_unquoted_glob && quoted_ranges.iter().any(|&(s, e)| word[s..e].contains('-'));
+        if (quoted_glob || quoted_dash) && has_unquoted_glob {
+            return Some(Token::QuotedGlobWord(
+                Self::escape_glob_metas_in_quoted_ranges(&word, &quoted_ranges),
+            ));
+        }
+        if extglob_escaped && !has_unquoted_expansion && !has_quoted_expansion {
+            // `@(a|'*')` with no match prints `@(a|*)` (quote removal).
             return Some(Token::QuotedGlobWord(
                 Self::escape_glob_metas_in_quoted_ranges(&word, &quoted_ranges),
             ));
@@ -1551,6 +1694,34 @@ impl<'a> Lexer<'a> {
                         None => content.push('\\'),
                     }
                 }
+                Some('(')
+                    if content.ends_with(['@', '?', '*', '+'])
+                        || (self.extglob_bang && content.ends_with('!')) =>
+                {
+                    // `"$*"*@(.py|cc)`: an extglob group after a quoted start.
+                    let mut depth = 0usize;
+                    while let Some(c) = self.peek_char() {
+                        content.push(c);
+                        self.advance();
+                        match c {
+                            '(' => depth += 1,
+                            ')' => {
+                                depth -= 1;
+                                if depth == 0 {
+                                    break;
+                                }
+                            }
+                            '\\' => {
+                                if let Some(e) = self.peek_char() {
+                                    content.push(e);
+                                    self.advance();
+                                }
+                            }
+                            _ => {}
+                        }
+                    }
+                    flags.has_unquoted_glob = true;
+                }
                 Some(ch) if self.is_word_char(ch) || matches!(ch, '{' | '}') => {
                     // `{` marks possible brace expansion, like a glob char.
                     if matches!(ch, '*' | '?' | '[' | '{') {
@@ -2040,7 +2211,20 @@ impl<'a> Lexer<'a> {
     fn is_glob_escape_char(ch: char) -> bool {
         matches!(
             ch,
-            '\\' | '*' | '?' | '[' | ']' | '{' | '}' | ',' | '@' | '!' | '+' | '(' | ')' | '|'
+            '\\' | '*'
+                | '?'
+                | '['
+                | ']'
+                | '{'
+                | '}'
+                | ','
+                | '@'
+                | '!'
+                | '+'
+                | '('
+                | ')'
+                | '|'
+                | '-'
         )
     }
 
@@ -2315,6 +2499,17 @@ impl<'a> Lexer<'a> {
                         i += 2;
                         continue;
                     }
+                    // `"$*"*`, `"$@"x*`, `"$?"`: a special parameter's
+                    // name is not a glob character.
+                    if let Some(&(_, next)) = char_vec.get(i + 1)
+                        && matches!(next, '*' | '@' | '?' | '!' | '-')
+                        && (i == 0 || char_vec[i - 1].1 != '\x00')
+                    {
+                        result.push(ch);
+                        result.push(next);
+                        i += 2;
+                        continue;
+                    }
                 } else if !expansion_stack.is_empty() {
                     // Track nesting: ${ … { … } … } and $( … ( … ) … )
                     let top = *expansion_stack.last().unwrap();
@@ -2349,6 +2544,7 @@ impl<'a> Lexer<'a> {
                             | '('
                             | ')'
                             | '|'
+                            | '-'
                     )
                 {
                     result.push('\\');
@@ -2595,6 +2791,33 @@ impl<'a> Lexer<'a> {
             if matches!(ch, ' ' | '\t' | '\n' | ';' | '&' | '|' | '<' | '>') {
                 break;
             }
+            if matches!(ch, '"' | '\'' | '$' | '`') {
+                // `[hello"]"`, `[$(echo abc)]`: quotes and expansions are
+                // read as in any word (a quoted `]` closes nothing).
+                return self.read_word_starting_with(&word);
+            }
+            if ch == '(' && word.ends_with(['@', '?', '*', '+', '!']) {
+                // `[+(])`: an extglob group inside the brackets.
+                let mut depth = 0usize;
+                while let Some(c) = self.peek_char() {
+                    if c == '\n' {
+                        break;
+                    }
+                    word.push(c);
+                    self.advance();
+                    match c {
+                        '(' => depth += 1,
+                        ')' => {
+                            depth -= 1;
+                            if depth == 0 {
+                                break;
+                            }
+                        }
+                        _ => {}
+                    }
+                }
+                continue;
+            }
             word.push(ch);
             self.advance();
             if ch == ']' {
@@ -2822,6 +3045,7 @@ impl<'a> Lexer<'a> {
             }
             rest_of_line.push(ch);
         }
+        let alias_rest = self.detach_alias_text();
 
         // Read lines until we find the delimiter
         loop {
@@ -2873,6 +3097,7 @@ impl<'a> Lexer<'a> {
             self.reinject_buf.push_back(ch);
         }
         self.reinject_buf.push_back('\n');
+        self.reinject_buf.extend(alias_rest);
 
         (content, rest_of_line_chars)
     }
diff --git a/crates/bashkit/src/parser/mod.rs b/crates/bashkit/src/parser/mod.rs
index 5d620e7be..97ce796d7 100644
--- a/crates/bashkit/src/parser/mod.rs
+++ b/crates/bashkit/src/parser/mod.rs
@@ -39,8 +39,21 @@ use crate::limits::LimitExceeded;
 use crate::time_compat::Instant;
 use raw::{heredoc_eof_from_raw, single_quote, split_raw_words};
 use std::cell::Cell;
+use std::collections::HashMap;
+use std::sync::Arc;
 use std::time::Duration;
 
+/// Shell state that changes how text parses, taken from the interpreter
+/// when a parse starts (bash reads and parses a line at a time, so an
+/// `alias` or `shopt -s extglob` affects the lines after it).
+#[derive(Debug, Clone, Default, PartialEq)]
+pub struct ParseOptions {
+    /// Aliases to expand (`shopt -s expand_aliases` on); `None` when off.
+    pub aliases: Option<Arc<HashMap<String, String>>>,
+    /// `shopt -s extglob`: `!(` starts a pattern group, not `!` + subshell.
+    pub extglob: bool,
+}
+
 /// Default maximum AST depth (matches ExecutionLimits default)
 const DEFAULT_MAX_AST_DEPTH: usize = 100;
 
@@ -97,6 +110,19 @@ pub struct Parser<'a> {
     failed_command_line: usize,
     /// Aggregate request budget shared by every child parser.
     execution_budget: Option<crate::limits::ExecutionBudget>,
+    /// Shell options that change parsing (aliases, extglob).
+    options: ParseOptions,
+    /// The current token is a word with no quoting (alias candidate).
+    current_plain: bool,
+    /// The current token follows a blank-ending alias value.
+    current_after_blank: bool,
+    /// The next `parse_command_list` call reads a top-level command: a
+    /// newline after `;` or `&` ends it, as bash's reader ends a line.
+    top_level_list: bool,
+    /// Byte offset and line where each top-level command starts.
+    top_starts: Vec<(usize, usize)>,
+    /// Offset and line of the top-level command being parsed.
+    failed_command_start: (usize, usize),
 }
 
 impl<'a> Parser<'a> {
@@ -137,6 +163,10 @@ impl<'a> Parser<'a> {
             Some(st) => (Some(st.token), st.span),
             None => (None, Span::new()),
         };
+        // The first token was lexed before any alias table was attached:
+        // it is plain when it reads exactly as its source text.
+        let current_plain = matches!(&current_token, Some(tokens::Token::Word(w))
+            if input.get(current_span.start.offset..current_span.end.offset) == Some(w.as_str()));
         Self {
             input,
             lexer,
@@ -155,6 +185,75 @@ impl<'a> Parser<'a> {
             error_was_deferred: false,
             failed_command_line: 0,
             execution_budget: None,
+            // Without shell options every extglob group lexes as one.
+            options: ParseOptions {
+                aliases: None,
+                extglob: true,
+            },
+            current_plain,
+            current_after_blank: false,
+            top_level_list: false,
+            top_starts: Vec::new(),
+            failed_command_start: (0, 1),
+        }
+    }
+
+    /// Parse with the shell's alias table and `extglob` setting.
+    pub fn with_options(mut self, options: ParseOptions) -> Self {
+        self.set_options(options);
+        self
+    }
+
+    fn set_options(&mut self, options: ParseOptions) {
+        self.lexer.set_track_plain(options.aliases.is_some());
+        self.lexer.set_extglob_bang(options.extglob);
+        self.options = options;
+    }
+
+    /// Count lines from `line` (text taken from later in a larger source).
+    pub(crate) fn starting_at_line(mut self, line: usize) -> Self {
+        let shift = line.saturating_sub(1);
+        if shift > 0 {
+            self.lexer.shift_lines(shift);
+            self.current_span.start.line += shift;
+            self.current_span.end.line += shift;
+        }
+        self
+    }
+
+    /// Expand an alias named by the current word, if it is one: its value
+    /// is read in place of the word (bash `alias_expand_token`).
+    /// THREAT[TM-DOS-030]: each expansion is charged to parser fuel by its
+    /// length, so chains of blank-ending aliases cannot grow without bound.
+    fn try_expand_alias(&mut self) -> bool {
+        let Some(aliases) = self.options.aliases.as_ref() else {
+            return false;
+        };
+        let Some(tokens::Token::Word(w)) = &self.current_token else {
+            return false;
+        };
+        if !self.current_plain || self.peeked_token.is_some() || self.lexer.alias_active(w) {
+            return false;
+        }
+        let Some(text) = aliases.get(w.as_str()) else {
+            return false;
+        };
+        let text = text.clone();
+        let name = w.clone();
+        if let Err(e) = self.tick_units(text.len() + 1) {
+            self.deferred_error.set(Some(e));
+            return false;
+        }
+        self.lexer.push_alias(&name, &text);
+        self.advance_token();
+        true
+    }
+
+    /// Expand aliases in command position (also through values that name
+    /// another alias: `alias FOR2='FOR1 '`).
+    fn expand_command_alias(&mut self) {
+        if self.options.aliases.is_some() {
+            while self.try_expand_alias() {}
         }
     }
 
@@ -355,6 +454,7 @@ impl<'a> Parser<'a> {
             let close = match msg.as_str() {
                 "unterminated double quote" => Some('"'),
                 "unterminated single quote" => Some('\''),
+                "unterminated subscript" => Some(']'),
                 _ => None,
             };
             if let Some(close) = close {
@@ -374,11 +474,14 @@ impl<'a> Parser<'a> {
         self.parse_script_into(&mut commands)?;
         let end_span = self.current_span;
         let (commands, command_end_lines) = commands.into_iter().unzip();
+        let command_starts = std::mem::take(&mut self.top_starts);
         Ok(Script {
             commands,
             span: start_span.merge(end_span),
             trailing_error: None,
             command_end_lines,
+            source: Some(Arc::from(self.input)),
+            command_starts,
         })
     }
 
@@ -417,12 +520,25 @@ impl<'a> Parser<'a> {
         };
         commands.truncate(keep);
         let (commands, command_end_lines) = commands.into_iter().unzip();
+        let mut command_starts = std::mem::take(&mut self.top_starts);
+        if err.is_some() {
+            // Where the unparsed rest starts: the first dropped command, or
+            // the one that failed.
+            let rest = command_starts
+                .get(keep)
+                .copied()
+                .unwrap_or(self.failed_command_start);
+            command_starts.truncate(keep);
+            command_starts.push(rest);
+        }
         (
             Script {
                 commands,
                 span: start_span.merge(end_span),
                 trailing_error: None,
                 command_end_lines,
+                source: Some(Arc::from(self.input)),
+                command_starts,
             },
             err,
         )
@@ -442,8 +558,12 @@ impl<'a> Parser<'a> {
                 break;
             }
             let start_offset = self.current_span.start.offset;
-            self.failed_command_line = self.current_span.start.line;
+            let start_line = self.current_span.start.line;
+            self.failed_command_line = start_line;
+            self.failed_command_start = (start_offset, start_line);
+            self.top_level_list = true;
             if let Some(cmd) = self.parse_command_list()? {
+                self.top_starts.push((start_offset, start_line));
                 commands.push((cmd, self.current_span.start.line));
             } else if self.current_token.is_some() && self.current_span.start.offset == start_offset
             {
@@ -462,22 +582,30 @@ impl<'a> Parser<'a> {
     }
 
     fn advance(&mut self) {
-        if let Some(peeked) = self.peeked_token.take() {
-            self.current_token = Some(peeked.token);
-            self.current_span = peeked.span;
-            self.current_raw = peeked.raw;
-        } else {
-            match self.lexer.next_spanned_token() {
-                Some(st) => {
-                    self.current_token = Some(st.token);
-                    self.current_span = st.span;
-                    self.current_raw = st.raw;
-                }
-                None => {
-                    self.current_token = None;
-                    self.current_raw = None;
-                    // Keep the last span for error reporting
-                }
+        self.advance_token();
+        // The word after a blank-ending alias value is checked too.
+        while self.current_after_blank && self.try_expand_alias() {}
+    }
+
+    fn advance_token(&mut self) {
+        let next = match self.peeked_token.take() {
+            Some(peeked) => Some(peeked),
+            None => self.lexer.next_spanned_token(),
+        };
+        match next {
+            Some(st) => {
+                self.current_token = Some(st.token);
+                self.current_span = st.span;
+                self.current_raw = st.raw;
+                self.current_plain = st.plain;
+                self.current_after_blank = st.after_blank_alias;
+            }
+            None => {
+                self.current_token = None;
+                self.current_raw = None;
+                self.current_plain = false;
+                self.current_after_blank = false;
+                // Keep the last span for error reporting
             }
         }
     }
@@ -501,6 +629,7 @@ impl<'a> Parser<'a> {
     /// Parse a command list (commands connected by && or ||)
     fn parse_command_list(&mut self) -> Result<Option<Command>> {
         self.tick()?;
+        let top_level = std::mem::take(&mut self.top_level_list);
         match self.current_token {
             Some(tokens::Token::Pipe) => return Err(self.error("unexpected token: |")),
             Some(tokens::Token::And) => return Err(self.error("unexpected token: &&")),
@@ -527,6 +656,11 @@ impl<'a> Parser<'a> {
                 }
                 Some(tokens::Token::Semicolon) => {
                     self.advance();
+                    // bash's reader ends a top-level command at the end
+                    // of its line: `{ls;` NL `}` runs `{ls` first.
+                    if top_level && matches!(self.current_token, Some(tokens::Token::Newline)) {
+                        break;
+                    }
                     self.skip_newlines()?;
                     // Check if there's more to parse
                     if self.current_token.is_none()
@@ -538,6 +672,10 @@ impl<'a> Parser<'a> {
                 }
                 Some(tokens::Token::Background) => {
                     self.advance();
+                    if top_level && matches!(self.current_token, Some(tokens::Token::Newline)) {
+                        rest.push(empty_background(self.current_span));
+                        break;
+                    }
                     self.skip_newlines()?;
                     // Check if there's more to parse after &
                     if self.current_token.is_none()
@@ -953,6 +1091,7 @@ impl<'a> Parser<'a> {
     fn parse_command(&mut self) -> Result<Option<Command>> {
         self.skip_newlines()?;
         self.check_error_token()?;
+        self.expand_command_alias();
 
         // Check for compound commands and function keyword
         if let Some(tokens::Token::Word(w)) = &self.current_token {
@@ -1122,6 +1261,8 @@ impl<'a> Parser<'a> {
             }
         };
         self.advance();
+        // `for i` NL `in a b`: newlines may come before `in` (not a `;`).
+        self.skip_newlines()?;
 
         // Check for 'in' keyword
         let words = if self.is_keyword("in") {
@@ -1182,21 +1323,13 @@ impl<'a> Parser<'a> {
 
         self.skip_newlines()?;
 
-        // Expect 'do'
-        self.expect_keyword("do")?;
-        self.skip_newlines()?;
-
-        // Parse body
-        let body = self.parse_compound_list("done")?;
-
-        // Bash requires at least one command in loop body
-        if body.is_empty() {
-            self.pop_depth();
-            return Err(self.error("syntax error: empty for loop body"));
-        }
-
-        // Expect 'done'
-        self.expect_keyword("done")?;
+        let body = match self.parse_for_body() {
+            Ok(body) => body,
+            Err(e) => {
+                self.pop_depth();
+                return Err(e);
+            }
+        };
 
         self.pop_depth();
         Ok(CompoundCommand::For(ForCommand {
@@ -1207,6 +1340,24 @@ impl<'a> Parser<'a> {
         }))
     }
 
+    /// A `for` body: `do list; done`, or bash's `{ list; }` form
+    /// (`for ((i=0; i<3; i++)) { echo $i; }`).
+    fn parse_for_body(&mut self) -> Result<Vec<Command>> {
+        if matches!(self.current_token, Some(tokens::Token::LeftBrace)) {
+            let group = self.parse_brace_group()?;
+            return Ok(vec![Command::Compound(group, Vec::new())]);
+        }
+        self.expect_keyword("do")?;
+        self.skip_newlines()?;
+        let body = self.parse_compound_list("done")?;
+        // Bash requires at least one command in loop body
+        if body.is_empty() {
+            return Err(self.error("syntax error: empty for loop body"));
+        }
+        self.expect_keyword("done")?;
+        Ok(body)
+    }
+
     /// Parse select loop: select var in list; do body; done
     fn parse_select(&mut self) -> Result<CompoundCommand> {
         let start_span = self.current_span;
@@ -1435,20 +1586,7 @@ impl<'a> Parser<'a> {
         }
         self.skip_newlines()?;
 
-        // Expect 'do'
-        self.expect_keyword("do")?;
-        self.skip_newlines()?;
-
-        // Parse body
-        let body = self.parse_compound_list("done")?;
-
-        // Bash requires at least one command in loop body
-        if body.is_empty() {
-            return Err(self.error("syntax error: empty for loop body"));
-        }
-
-        // Expect 'done'
-        self.expect_keyword("done")?;
+        let body = self.parse_for_body()?;
 
         Ok(CompoundCommand::ArithmeticFor(ArithmeticForCommand {
             init,
@@ -1991,8 +2129,18 @@ impl<'a> Parser<'a> {
                         parsed
                     };
                     words.push(self.with_raw(word));
+                    // bash reads the pattern after `==`/`!=`/`=` with extglob
+                    // on: `[[ x == --!(a|b) ]]` needs no `shopt -s extglob`.
+                    let pattern_next = matches!(op_text.as_deref(), Some("==" | "!=" | "="));
                     kinds.push(CondTok::Word(op_text));
-                    self.advance();
+                    if pattern_next {
+                        let saved = self.lexer.extglob_bang();
+                        self.lexer.set_extglob_bang(true);
+                        self.advance();
+                        self.lexer.set_extglob_bang(saved);
+                    } else {
+                        self.advance();
+                    }
                 }
                 // Operators that the lexer tokenizes separately
                 Some(tokens::Token::And) => {
@@ -3103,6 +3251,11 @@ impl<'a> Parser<'a> {
         let mut redirects = Vec::new();
 
         loop {
+            if words.is_empty() {
+                // `FOO=1 ll`, `>f ll`: the first word after assignments and
+                // redirects is a command name.
+                self.expand_command_alias();
+            }
             match &self.current_token {
                 Some(
                     tokens::Token::Word(_)
@@ -3258,7 +3411,15 @@ impl<'a> Parser<'a> {
 
         // Handle compound array assignment in arg position:
         // declare -a arr=(x y z) → arr=(x y z) as single arg
-        if w.ends_with('=') && !words.is_empty() {
+        // Only a declaration builtin, `let` or `eval` named directly takes
+        // one: bash rejects `builtin declare a=(x)`, `echo a=(x)` and
+        // `command typeset a=(x)` at `(`.
+        let decl_command = words.first().is_some_and(|w0| {
+            !w0.quoted
+                && matches!(w0.parts.as_slice(), [WordPart::Literal(n)]
+                    if matches!(n.as_str(), "declare" | "typeset" | "local" | "export" | "readonly" | "let" | "eval"))
+        });
+        if w.ends_with('=') && decl_command {
             let saved_raw = self.current_raw.clone();
             self.advance();
             if let Some(word) = self.try_parse_compound_array_arg(w.clone(), saved_raw.clone()) {
@@ -3756,6 +3917,7 @@ impl<'a> Parser<'a> {
         let remaining_depth = self.max_depth.saturating_sub(self.current_depth);
         let mut parser = Box::new(Parser::with_limits(src, remaining_depth, self.fuel));
         parser.execution_budget = self.execution_budget.clone();
+        parser.set_options(self.options.clone());
         // `$( )` spans count from the outer word's line, so `$LINENO` and
         // error line numbers inside it match bash.
         let shift = self.current_span.start.line.saturating_sub(1);
@@ -5101,7 +5263,7 @@ pub(crate) fn unescape_glob_literal(s: &str) -> String {
             && let Some(&next) = chars.peek()
             && matches!(
                 next,
-                '\\' | '*' | '?' | '[' | ']' | '{' | '}' | '@' | '!' | '+' | '(' | ')' | '|'
+                '\\' | '*' | '?' | '[' | ']' | '{' | '}' | '@' | '!' | '+' | '(' | ')' | '|' | '-'
             )
         {
             out.push(next);
diff --git a/crates/bashkit/tests/integration/compgen_tests.rs b/crates/bashkit/tests/integration/compgen_tests.rs
index ea8d588b9..4c441279c 100644
--- a/crates/bashkit/tests/integration/compgen_tests.rs
+++ b/crates/bashkit/tests/integration/compgen_tests.rs
@@ -1,8 +1,8 @@
 //! Behavioral tests for `compgen` builtin/function/alias listing.
 //!
-//! `compgen -b` must reflect the live builtin registry — the same source
-//! `Bash::builtin_names()` reads — not a hardcoded list that drifts as
-//! builtins are added (it sat at 109 names while the registry had 156).
+//! `compgen -b` reads the live builtin registry — the same source
+//! `Bash::builtin_names()` reads — keeping bash's own builtins and
+//! host-registered commands (the rest stand in for programs: `-c` only).
 
 use std::collections::HashSet;
 use std::sync::Arc;
@@ -27,7 +27,7 @@ fn stdout_set(result: &ExecResult) -> HashSet<String> {
 }
 
 #[tokio::test]
-async fn compgen_b_matches_builtin_names() {
+async fn compgen_b_lists_bash_builtins_in_the_registry() {
     let mut bash = Bash::new();
     let names: HashSet<String> = bash.builtin_names().into_iter().collect();
 
@@ -35,9 +35,13 @@ async fn compgen_b_matches_builtin_names() {
     assert_eq!(result.exit_code, 0, "stderr: {}", result.stderr);
     let listed = stdout_set(&result);
 
-    assert_eq!(
-        listed, names,
-        "compgen -b must list exactly the registered builtins"
+    // bash's own builtins that bashkit registers; commands standing in for
+    // programs (`awk`, `grep`) are `-c` only, as in bash.
+    assert!(listed.contains("getopts") && listed.contains("echo"));
+    assert!(!listed.contains("grep") && !listed.contains("awk"));
+    assert!(
+        listed.is_subset(&names),
+        "compgen -b lists only registered names"
     );
 }
 
@@ -58,11 +62,13 @@ async fn compgen_b_includes_host_registered_builtin() {
 #[tokio::test]
 async fn compgen_action_builtin_lists_builtins_only() {
     let mut bash = Bash::new();
-    // `awk` is a bashkit builtin; with -A builtin it must appear even though
-    // it's not a builtin in real bash.
+    // `awk` is a bashkit builtin standing in for a program; like bash,
+    // `-A builtin` lists only bash's builtins (`getopts`).
     let result = bash.exec("compgen -A builtin awk").await.unwrap();
-    assert_eq!(result.exit_code, 0, "stderr: {}", result.stderr);
-    assert_eq!(result.stdout, "awk\n");
+    assert_eq!(result.exit_code, 1, "stderr: {}", result.stderr);
+    assert_eq!(result.stdout, "");
+    let result = bash.exec("compgen -A builtin g").await.unwrap();
+    assert_eq!(result.stdout, "getopts\n");
 
     // -A builtin must NOT include functions.
     let result = bash
diff --git a/crates/bashkit/tests/spec_cases/bash/oils-final-gaps.test.sh b/crates/bashkit/tests/spec_cases/bash/oils-final-gaps.test.sh
new file mode 100644
index 000000000..c594f067c
--- /dev/null
+++ b/crates/bashkit/tests/spec_cases/bash/oils-final-gaps.test.sh
@@ -0,0 +1,207 @@
+# Oils spec gaps closed in one pass: aliases per line, parser, globbing,
+# arrays, errexit, redirects, verbose and LINENO.
+# Every expectation verified against real bash 5.2.
+
+### alias_not_expanded_on_defining_line
+# An alias defined on a line is not in effect until the next line
+shopt -s expand_aliases
+alias e='echo one'; e 2>/dev/null || echo not-yet
+e
+### expect
+not-yet
+one
+### end
+
+### alias_blank_ending_expands_next_word
+shopt -s expand_aliases
+alias run='echo '
+alias x='hi'
+run x
+### expect
+hi
+### end
+
+### alias_for_left_brace
+shopt -s expand_aliases
+alias LEFT='{'
+LEFT echo one; echo two; }
+### expect
+one
+two
+### end
+
+### alias_loop_split_across_aliases
+shopt -s expand_aliases
+alias FOR1='for '
+alias FOR2='FOR1 '
+alias eye1='i '
+alias eye2='eye1 '
+alias IN='in '
+alias onetwo='$one "2" '
+one=1
+FOR2 eye2 IN onetwo 3; do echo $i; done
+### expect
+1
+2
+3
+### end
+
+### for_brace_body
+for i in a b; { echo $i; }
+### expect
+a
+b
+### end
+
+### for_newline_before_in
+for i
+in x y
+do echo $i; done
+### expect
+x
+y
+### end
+
+### dparen_with_redirect
+(( a = 1 + 2 )) 2>/dev/null
+echo $a
+(( 1 / 0 )) 2>/dev/null
+echo status=$?
+### expect
+3
+status=1
+### end
+
+### lineno_in_dparen
+echo first
+(( x = LINENO ))
+echo $x
+### expect
+first
+2
+### end
+
+### glob_escaped_dash_in_class
+mkdir -p /tmp/ofg_dash && cd /tmp/ofg_dash && touch ./- C D E
+echo [C\-D]
+### expect
+- C D
+### end
+
+### glob_globskipdots_off
+mkdir -p /tmp/ofg_dots && cd /tmp/ofg_dots && touch .a
+shopt -u globskipdots
+echo .*
+### expect
+. .. .a
+### end
+
+### extglob_no_match_is_literal
+shopt -s extglob
+cd /tmp
+echo @(ofg_nope|ofg_nada)
+### expect
+@(ofg_nope|ofg_nada)
+### end
+
+### failglob_aborts_rest_of_line
+shopt -s failglob
+cd /tmp
+echo ofg_zz*.ZZ; echo not-reached
+echo status=$?
+### expect
+status=1
+### end
+
+### array_subscript_side_effect
+a=(10 20 30)
+i=0
+echo ${a[i++]} ${a[i++]} i=$i
+### expect
+10 20 i=2
+### end
+
+### array_element_prefix_assignment_rejected
+a=(1 2)
+a[1]=x true 2>/dev/null
+echo status=$? a1=${a[1]}
+### expect
+status=0 a1=2
+### end
+
+### builtin_prefix_array_literal_is_syntax_error
+# Only a literal declaration builtin takes `name=(...)`; `builtin declare` does not
+eval 'builtin declare a=(x y)' 2>/dev/null
+echo status=$?
+eval 'declare a=(x y)'
+echo ${#a[@]}
+### expect
+status=2
+2
+### end
+
+### declare_array_literal_quoted_splat
+b=(x 'y z')
+declare -a a=("${b[@]}" w)
+echo ${#a[@]}
+printf '<%s>' "${a[@]}"; echo
+### expect
+3
+<x><y z><w>
+### end
+
+### tilde_in_default_operand_of_assignment
+HOME=/home/ofg
+x=${ofg_undef-~:~}
+echo $x
+### expect
+/home/ofg:/home/ofg
+### end
+
+### tilde_in_regex_operand
+HOME=/home/ofg
+[[ /home/ofg/x =~ ~/x ]] && echo match
+### expect
+match
+### end
+
+### errexit_in_negated_function
+foo() {
+  set -e
+  false
+  echo should-not-print
+}
+! foo
+echo after
+### expect
+### end
+
+### function_redirect_evaluated_per_call
+i=0
+fun() { echo "file $i"; } 1> "/tmp/ofg_file$((i++))"
+fun
+fun
+echo i=$i
+cat /tmp/ofg_file0 /tmp/ofg_file1
+### expect
+i=2
+file 1
+file 2
+### end
+
+### redirect_to_multiword_at_is_ambiguous
+set -- a b
+echo hi 1> "$@" 2>/dev/null
+echo status=$?
+### expect
+status=1
+### end
+
+### set_v_echoes_source_lines
+exec 2>&1
+set -v
+echo a
+### expect
+echo a
+a
+### end
diff --git a/knowledge/foundations/parser.md b/knowledge/foundations/parser.md
index 1bd930f12..8b6db3146 100644
--- a/knowledge/foundations/parser.md
+++ b/knowledge/foundations/parser.md
@@ -246,6 +246,33 @@ when the operator uses the operand, so an unused default never executes.
 `${x:-$(echo })}`: the lexer and `read_brace_operand` let a substitution own
 its braces.
 
+**Aliases expand at parse time, per line.** The interpreter hands the
+parser a `ParseOptions` (alias table under `expand_aliases`, `extglob`).
+When a command word is a plain (unquoted, unexpanded) alias name, the parser
+pushes the value to the front of the lexer's reinject buffer (alias text does
+not move source positions) and lexes on, so a value may hold `{`, `(`,
+keywords or half a loop. `alias_stack` stops recursion, a value ending in a
+blank makes the next word a candidate, and every expansion ticks the parser's
+fuel (TM-DOS-030/031). A here-doc started inside an alias reads its body from
+the next real input line. The script records each top-level command's start
+(`Script::command_starts`, with the source; both `#[serde(skip)]`, so the
+snapshot AST format is unchanged). When `alias`/`unalias`/`shopt extglob`
+changes the options mid-script, the body loop re-parses the rest from the
+next command that starts a new line (`reread_script_rest`), as bash reads
+line by line: `alias e=..; e` on one line misses `e`, the next line sees
+it. At the top level `;`/`&` followed by a newline ends the command, so the
+next line can be re-read. `eval` and `source` go through the same loop.
+
+**`!(` needs extglob.** `!(` lexes as an extglob group only when `extglob` is
+on (a re-read after `shopt -s extglob` picks it up); otherwise it is `!` then
+a subshell. The right operand of `==`/`!=`/`=` in `[[ ]]` always lexes
+extglob, like bash.
+
+**Compound array arguments.** `name=(...)` as an argument is a declaration
+operand only after an unquoted literal `declare`, `typeset`, `local`,
+`export`, `readonly`, `let` or `eval`; `builtin declare a=(x)` and
+`command declare a=(x)` are syntax errors, as in bash.
+
 ## Alternatives Considered
 
 - PEG (pest, pom): rejected, bash grammar is context-sensitive, here-docs awkward, manual parser gives better errors.
diff --git a/knowledge/log.md b/knowledge/log.md
index 50e2877de..e0d0788d3 100644
--- a/knowledge/log.md
+++ b/knowledge/log.md
@@ -1,5 +1,9 @@
 # Bashkit Knowledge Update Log
 
+## 2026-10-09
+
+* **Fix**: Oils final gaps. Aliases expand at parse time and per line like bash: an alias defined on a line takes effect from the next line, values may hold `{`, `(`, keywords or half a loop, blank-ending values chain through nested aliases, a here-doc in an alias reads its body from the next line; the body loop re-parses the rest of a script, `eval` or `source` text from the next line when `alias`/`unalias`/`shopt extglob` change (foundations/parser). `!(` is an extglob only under `extglob` (always on the right of `[[ == ]]`); a no-match extglob prints its pattern unescaped; `[C\-D]` holds a literal `-` in pathname globs; `shopt -u globskipdots` and `GLOBIGNORE=.:..` list `.` and `..`; `failglob` abandons the rest of the line (also in an array literal). `for i in x; { ...; }` and `for i` with `in` on the next line parse; `(( )) 2>f` takes redirects; `a[` with no `]` is `unterminated subscript`; `name=(..)` arguments only after a literal `declare`/`typeset`/`local`/`export`/`readonly`/`let`/`eval`. `${a[i++]}` evaluates its side effect; `a[i]=x cmd` is `not a valid identifier`; `declare a=("${b[@]}")` splats. `${undef-~:~}` in an assignment and `[[ x =~ ~/y ]]` expand the tilde; `! f` with `set -e` inside `f` still exits; a function's redirect is expanded at each call; `> "$@"` with several words is ambiguous; `set -v`/`bash -v` echo the top-level lines as they are read (through `exec 2>` targets); a top-level `(( ))`/`[[ ]]` sets `$LINENO` (and DEBUG's) to its own line; `compgen -A builtin`/`-b` list only bash's builtins and host-registered ones, not the commands standing in for programs (`awk`, `grep`). Oils spec pass rate 95.8% to 97.3% (40 cases, no new misses; `alias`, `extglob-files`, `glob-bash`, `assign-deferred` and 15 more files to 0); 74 misses left, by cause under limitations "Oils Spec Misses".
+
 ## 2026-10-08
 
 * **Fix**: Oils long tail. `test`/`[` follow bash's `test.c` grammar (argument-count rules, `-a`/`-o`/`!`/`( )` precedence, `argument expected`, `)' expected`, `too many arguments`). `$empty cmd` runs `cmd`; `PWD`/`OLDPWD` are exported; `B=(b b) cmd` binds the text `(b b)` for `cmd` only. `rm` reports each bad operand and goes on; `cat` reads buffered stdin once; `date foo` fails; `umask 1 2` uses the first operand; `history -5` is an invalid option; `help help`, `help -- X` and bash's `no help topics match`; `set +` is ignored; `getopts` rejects a bad variable name and unsets `OPTARG` at the end. `shift 1 2` (like `exit`/`break`/`continue` with extra operands) discards the line, and a builtin's discard ends a child `bash -c` string (status 1) while expansion errors still resume. Arithmetic: `set -u` makes an unbound name fatal (also in `${#v}`/`${v:..}`), backticks and `\`-newline work inside, a base with a leading zero (`010#1`) is invalid, `a[$(cmd)]=v` and `${a[$(cmd)]}` run the substitution, `a[]=x` and `${a[]}` are bad subscripts. Array literals evaluate subscripts in order (`[i++]=x`, self references), skip tilde for assoc values, and refuse bare assoc elements; `a["k"]=v` and nameref targets `A["K"]`/`A[$key]` resolve quoted and variable keys; `declare -nx` exports. `printf %q` and `${x@Q}`/`@A` use `$'...'` for control characters; `$'\cX'` and invalid `\u` match bash; `${s:}` is a bad substitution; quotes nested in a double-quoted `${..}` operand stay protected; `{a,b}""` keeps brace expansion; `f() ...` with `$`/quotes in the name and `cmd (` are refused. `unset PS4` traces with no prefix; `time a | b` keeps its output. Oils spec pass rate 92.8% to 95.8% (79 cases, no new misses; `array-literal`, `array`, `blog2`, `bool-parse`, `builtin-misc`, `func-parsing`, `builtin-getopts`, `builtin-set`, `exit-status`, `var-op-slice` to 0); every remaining miss is categorized under limitations "Oils Spec Misses".
diff --git a/knowledge/operations/limitations.md b/knowledge/operations/limitations.md
index 27c6d6d5b..b24eeaa34 100644
--- a/knowledge/operations/limitations.md
+++ b/knowledge/operations/limitations.md
@@ -109,21 +109,21 @@ Target: IEEE 1003.1-2024 Shell Command Language.
 | `return` | Basic usage | Return value propagation |
 | `time` | Reserved-word pipelines; `-p`, `--`, GNU `-f/-o/-a/-v`; `TIMEFORMAT` (`%[p][l]R`, `%%`, empty = no report); elapsed time, exit status, and Bashkit counters | Host user/system CPU, RSS, and other process metrics are reported as `unavailable`, never fabricated (also `TIMEFORMAT`'s `%U`/`%S`/`%P`) |
 | `timeout` | Basic usage | `-k` kill timeout |
-| `bash`/`sh` | `-c` anywhere among the options (the command is the first operand, then `$0` and the arguments), `-n`, every `set` letter, `-o`/`+o option`, `-O`/`+O shopt`, `-`/`--` end options, script files, stdin, `--version`, `--help`; `export SHELLOPTS` passes the `set -o` options on; `env -i bash` still gets `PATH`, `PWD`, `IFS`, `PS2`, `PS4`, `SHELLOPTS` | Login shell; `-v` (and `set -v`) is accepted but input lines are not echoed; `$-` holds `c` for every `-c` run (the Oils harness runs bash from stdin, where it is `s`); `-i` gives an interactive child (see Interactive builtins row) but no terminal, line editing, job control or `PS2` continuation prompt |
+| `bash`/`sh` | `-c` anywhere among the options (the command is the first operand, then `$0` and the arguments), `-n`, every `set` letter, `-o`/`+o option`, `-O`/`+O shopt`, `-`/`--` end options, script files, stdin, `--version`, `--help`; `export SHELLOPTS` passes the `set -o` options on; `env -i bash` still gets `PATH`, `PWD`, `IFS`, `PS2`, `PS4`, `SHELLOPTS` | Login shell; `-v` (and `set -v`) echoes the top-level script's lines as each command is read, but not the lines of `source`d files or `eval` text (bash echoes those too); `$-` holds `c` for every `-c` run (the Oils harness runs bash from stdin, where it is `s`); `-i` gives an interactive child (see Interactive builtins row) but no terminal, line editing, job control or `PS2` continuation prompt |
 | Interactive builtins | `history` (`-c -d -a -n -r -w -p -s`, `HISTSIZE`/`HISTFILESIZE`, `histappend`), `fc -l/-n/-r/-s`, `complete`/`compgen`/`compopt` (actions, `-W -G -F -C -X -P -S`, `-o` options, `complete -p` in bash's format), `bind` (bash's default emacs bindings, `-l -p -P -s -S -v -V -X -q -u -r -x -m -f`), prompt decoding (`${x@P}`, `PS1` printed to stderr and `PROMPT_COMMAND` run per line of a `bash -i` stdin script, `\!` `\#` `\u` `\h` `\w` `\t` `\D{fmt}` ...) | `fc` without `-s`/`-l` cannot open an editor (L-HIST-001); no `!` history expansion; `bind` changes are recorded but nothing reads keys, and the vi keymaps list no defaults; `complete -p` lists specs in definition order (bash: hash order); history numbers after `HISTSIZE` trims count from 1 in the trimmed list; `PS2` is never printed; `-A service` and `-A disabled` list nothing; `compgen -A user`/`-u` read the sandbox `/etc/passwd` or fall back to the sandbox user; `compgen -b` lists bashkit's builtin registry (`awk`, `grep`, ...), not bash's list |
 | Expansion errors | `set -u` unbound variables stop the shell | `$((1/0))` evaluates to 0 and `${x!}` expands empty; bash reports them and drops the rest of the line the failing command ends on (`bashbox_line_number_an_expansion_error_drops_the_rest_of_the_line_it_ends_on`, skipped) |
 | Process substitution | `<(cmd)` and `>(cmd)` as filenames, nesting, redirections | Paths are bash's `/dev/fd/63`, `/dev/fd/62`, ... per command, resolved in the shell's own fd namespace, never the shared VFS (TM-ISO-028; `process_substitution_fd_tests.rs`). The data is buffered, not a pipe: `<(cmd)` runs to completion before the command, `>(cmd)` runs after it. `readlink` prints `pipe:[N]` with the fd as N, not an inode; `ls /dev/fd` lists none of them; `exec 3> >(cmd)` runs `cmd` right after the `exec` with no input; later writes to fd 3 are dropped. `[[ -e <(true) ]]` and `for x in <(a)` do not parse a substitution there. A substitution is always its own word: bash joins it to adjacent text (`x<(true)` is `x/dev/fd/63`, `x=<(true)` assigns the path), Bashkit splits it off (`bashbox-process-substitution.test.sh`, skipped). The substituted list runs in a subshell, as in bash |
 | `cd` / `pwd` | `-L`/`-P`/`--`, `cd -` (prints the directory), `CDPATH`, `pwd -P`, bash's errors (`too many arguments`, `OLDPWD not set`, `cd nope/..` fails) | Assigning or unsetting `PWD` sticks until the next `cd`; there is no host startup directory, so a shell never starts inside a symlinked path and `pwd` at startup cannot show one |
-| Special variables | `$_` (last argument, empty after an assignment-only command, `/bin/bash` at startup), `$BASHPID` (a fresh virtual pid per subshell, `$$` unchanged), `SHELLOPTS`/`BASHOPTS` (computed, readonly), `UID`/`EUID`/`PPID` readonly integers; `$LINENO` in `for (( ))` clauses is the `for` line | The environment starts empty (sandbox identity), so `env` does not list `PWD` and `HOME` is always set; `HISTFILE` is set only by `bash -i` (and read/written through the VFS only); a top-level `(( ))` keeps the line of the command before it for `$LINENO` (the AST stores no position for it) |
-| `GLOBIGNORE` | Colon-separated patterns (`:` inside `[...]` kept), matched per path component, `.`/`..` dropped, non-empty value turns `dotglob` on, an emptied match list falls back to the literal word / `nullglob` / `failglob` | `shopt -u globskipdots` is accepted but has no effect: `.*` never yields `.` and `..` (bash 5.2 does once `globskipdots` is off), since the VFS lists no such entries |
-| Aliases | `alias`/`unalias`, `shopt -s expand_aliases`, trailing-space chaining, recursion guard | Expanded when the simple command runs, not when its line is read: bash parses a whole line (and a function body at definition) before an `alias`/`unalias` on it takes effect; Bashkit applies them to the very next command |
+| Special variables | `$_` (last argument, empty after an assignment-only command, `/bin/bash` at startup), `$BASHPID` (a fresh virtual pid per subshell, `$$` unchanged), `SHELLOPTS`/`BASHOPTS` (computed, readonly), `UID`/`EUID`/`PPID` readonly integers; `$LINENO` in `for (( ))` clauses is the `for` line | The environment starts empty (sandbox identity), so `env` does not list `PWD` and `HOME` is always set; `HISTFILE` is set only by `bash -i` (and read/written through the VFS only); a `(( ))` nested in a compound command keeps the line of the command before it for `$LINENO` (the AST stores no position for it; top-level ones take the line they start on) |
+| `GLOBIGNORE` | Colon-separated patterns (`:` inside `[...]` kept), matched per path component, `.`/`..` dropped, non-empty value turns `dotglob` on, an emptied match list falls back to the literal word / `nullglob` / `failglob` | `.` and `..` are added to a dot-prefixed component's candidates only when `globskipdots` is off (the VFS lists no such entries) |
+| Aliases | `alias`/`unalias`, `shopt -s expand_aliases`, trailing-space chaining, recursion guard; expanded at parse time like bash: an alias defined on a line takes effect from the next line, a function body expands at definition, aliases may hold `{`, `(`, keywords or half a loop, and a here-doc in an alias reads its body from the next line | None known (`eval` and `source` text is read line by line too) |
 | Named fds / `<>` | `{var}>file`, `{var}<file`, `{var}<>file`, `{var}>>file`, `{var}<<<w`, `{var}<<E`, `{var}>&N`/`<&N` allocate the lowest free fd >= 10 on any command (persisting, as in bash); `{var}>&-` closes; `>&N` with N closed is `Bad file descriptor`; `N<>file`, `N<<<w` for any N | Descriptors are virtual: `N<>file` has no shared read/write offset (writes append, so `read -n 1 <&3; echo . >&3` does not overwrite the second byte); a `mkfifo` file is not a pipe, so `exec 8<> fifo` round-trips nothing; a fd moved for one command (`: 6>&7-`) is back afterwards, where bash 5.2 leaves it closed (a bash bug Oils pins); `3<file` also feeds stdin; output to fd 3-9 opened by a command's own redirect (`f 3>&1`, `( ... ) 3>&1`) is dropped; a `Bad file descriptor` message ignores redirect order (`2>&1 >&7`); output to a stdout closed by the command's own `>&-` reports `write error: Bad file descriptor` without naming the command, since the redirect is applied after it ran |
 | Locale | UTF-8 text everywhere; `${#v}` counts bytes when `LC_ALL`/`LC_CTYPE`/`LANG` (first non-empty) is `C` or `POSIX` | With no locale variable set bashkit is UTF-8, where bash falls back to C. Under C, `${s:off:len}`, `${s^^}`, `${s#?}` and glob `?` (in patterns and pathname expansion: `LC_ALL=C; echo _?_` still matches `_μ_`) still work on characters, not bytes, and an invalid `LC_CTYPE` gives no `setlocale` warning: shell words are Rust strings and cannot hold a split UTF-8 sequence (L-STREAM-001) |
-| Diagnostic prefix | `$0: line N: ` on interpreter and shell-builtin messages, `$0` = sourced file inside `source`; `eval` text counts lines from the eval's own line; syntax errors read like bash (`near unexpected token `T'` plus the offending line, `unexpected end of file` on the line after the last, `unexpected EOF while looking for matching `"'`), named `bash: -c`, the script path, `$0: eval` or the sourced file | `(( ))`, `[[ ]]`, `{ }` and `( )` carry no span: `(( ))`/`[[ ]]` keep the line of the list or command before them, `{ }`/`( )` report line 1 at the top level when the construct itself (not a command inside it) fails; a function defined in a sourced file and called from the script names the caller's file (bash names the defining file); `${3}` under `set -u` reports `$3` (bash: `3`, only bare `$3` gets the `$`); `command not found` keeps the sandbox "Did you mean" / unavailable-command hint bash does not print; parse errors outside the grammar (`((` unterminated, `$(` unterminated, `[[ ]]` operand errors other than an unclosed `=~` group) keep bashkit's wording, and `x=(` with no `)` is accepted; under the CLI's `-c` a syntax error after commands that ran is named `bash: line N` (bash: `bash: -c: line N`); an `eval` command spanning several lines counts from its first line (bash: its last), and a function defined inside `eval` numbers `$LINENO` from the eval text, not the script |
+| Diagnostic prefix | `$0: line N: ` on interpreter and shell-builtin messages, `$0` = sourced file inside `source`; `eval` text counts lines from the eval's own line; syntax errors read like bash (`near unexpected token `T'` plus the offending line, `unexpected end of file` on the line after the last, `unexpected EOF while looking for matching `"'`), named `bash: -c`, the script path, `$0: eval` or the sourced file | `(( ))`, `[[ ]]`, `{ }` and `( )` carry no span: `(( ))`/`[[ ]]` inside a compound command keep the line of the command before them (top-level ones use the line they start on), `{ }`/`( )` report line 1 at the top level when the construct itself (not a command inside it) fails; a function defined in a sourced file and called from the script names the caller's file (bash names the defining file); `${3}` under `set -u` reports `$3` (bash: `3`, only bare `$3` gets the `$`); `command not found` keeps the sandbox "Did you mean" / unavailable-command hint bash does not print; parse errors outside the grammar (`((` unterminated, `$(` unterminated, `[[ ]]` operand errors other than an unclosed `=~` group) keep bashkit's wording, and `x=(` with no `)` is accepted; under the CLI's `-c` a syntax error after commands that ran is named `bash: line N` (bash: `bash: -c: line N`); an `eval` command spanning several lines counts from its first line (bash: its last), and a function defined inside `eval` numbers `$LINENO` from the eval text, not the script |
 | Stderr routing | A command's own errors (`command not found`, a missing `./path`, `return`/`exit`/`source`/`getopts`/`builtin` usage errors) follow its redirects; stderr written inside `$(...)` reaches the outer stderr ahead of the expanding command's own, outside that command's redirects and inside a compound command's ; under `2>&1` (or `&>`, `>f 2>&1`) on a group, function, script, `eval`, `source` or `bash` child each inner command's stderr merges in write order between commands | within one command stdout and stderr are separate values, so a builtin that writes both (`cat a missing b 2>&1`) gives all its stdout first; a streaming caller gets each command's stdout and stderr as one chunk (the CLI writes stdout first, so `set -x` lines follow the output they trace on a terminal); `exit 1 2` drops the rest of the line and carries on like `bash SCRIPT` even under `bash -c` (bash -c exits 1) |
-| `set -x` | Simple commands with bash's word quoting (`''`, `'a b'`, `$'\001'`), assignments (`+ a=1`, `+ arr=(1 $(x))` as written), function calls, `[[ ]]` primaries; PS4 expanded (`$LINENO`, `$(...)`) with its first character repeated per `$(...)`/`eval`/`source`/trap level | `for`/`case`/`select` headers are not traced; a quoted `[[ == ]]` pattern shows only glob characters escaped (bash escapes each quoted character); `unset PS4` still prefixes `+ ` (PS4 is not seeded, so unset and never-set look alike); `set -o verbose` does not echo input lines; a `<(...)` body is not traced |
+| `set -x` | Simple commands with bash's word quoting (`''`, `'a b'`, `$'\001'`), assignments (`+ a=1`, `+ arr=(1 $(x))` as written), function calls, `[[ ]]` primaries; PS4 expanded (`$LINENO`, `$(...)`) with its first character repeated per `$(...)`/`eval`/`source`/trap level | `for`/`case`/`select` headers are not traced; a quoted `[[ == ]]` pattern shows only glob characters escaped (bash escapes each quoted character); `unset PS4` still prefixes `+ ` (PS4 is not seeded, so unset and never-set look alike); a `<(...)` body is not traced |
 | Tilde expansion | A leading unquoted `~`, `~+`, `~-`; in assignments (and `name=` arguments such as `local x=a:~`) after `=` and each `:`; `${x:-~}` operands when unquoted; pattern operands (`${x#~}`, `${x//~/y}`) even quoted; quoted, escaped or expansion-joined prefixes stay literal (`~"x"`, `\~`, `~$v`) | No user database: only `~root` (`/root`) and `~<sandbox user>` (`/home/<user>`) resolve, other `~name` stays literal; no `~N`/`~+N` directory-stack forms; a `${v-~:~}` operand inside an assignment gets only the leading tilde; `x=~` inside `a=( ... )` is expanded (bash leaves it) |
-| DEBUG trap | Fires before simple commands, `(( ))`, `[[ ]]`, `case`, each `for` round and arithmetic-`for` clause, and each pipeline stage (run in the shell, before the stages); `$?` survives it; `return` in it returns from the function, `exit` ends the shell; inherited by functions, subshells and `$(...)` only under `set -T` (plus once on function entry), a handler set inside a function stays | `$BASH_COMMAND` is not set; `$LINENO` inside the handler for a top-level `(( ))`/`[[ ]]` is the previous command's line (no span on those nodes); `shopt -s extdebug` (status 2 skipping the command, `declare -F` file/line) is not implemented |
+| DEBUG trap | Fires before simple commands, `(( ))`, `[[ ]]`, `case`, each `for` round and arithmetic-`for` clause, and each pipeline stage (run in the shell, before the stages); `$?` survives it; `return` in it returns from the function, `exit` ends the shell; inherited by functions, subshells and `$(...)` only under `set -T` (plus once on function entry), a handler set inside a function stays | `$BASH_COMMAND` is not set; `$LINENO` inside the handler for a `(( ))`/`[[ ]]` nested in a compound command is the previous command's line (no span on those nodes); `shopt -s extdebug` (status 2 skipping the command, `declare -F` file/line) is not implemented |
 | Arrays | Sparse indexed and associative arrays, slices by index (`${a[@]:1:2}`, negative offsets from the highest index), `a[i]` subscripts evaluated arithmetically on read and write (side effects once), `${!ref}` through `a[i]`/`a[@]` targets with any operator | Quotes inside an indexed subscript are removed before a read (`${a['1']}` is element 1 in bashkit, an arithmetic syntax error in bash); `B=(x) cmd` binds the text `(x)` as bash does, but an existing array `B` still shadows that binding inside `cmd`; writing through a nameref to `a[@]` (`ref=(x)`) is not refused like bash |
 | Brace expansion | Runs before other expansions on unquoted literal text; lists, nesting, ranges with step and zero padding, quoted/escaped braces and commas | Works on parsed words, not raw text: `$v{1,2}` expands `$v` then appends `1`/`2` (bash reads `$v1`, `$v2`); write `${v}` |
 
@@ -261,13 +261,11 @@ the latest saved run; a case listed here is a known gap, not a regression.
 | Harness artifacts (the harness runs bashkit with `-c`, bash from stdin) | 6 | Under `-c` bash ends the string on a fatal expansion error with 127 and `$-` holds `c`; bashkit's top level keeps script semantics; the harness host has no `$HOME`/passwd shell, and bashkit seeds `PIPESTATUS` | `fatal-errors #${undef} with nounset`; `fatal-errors #Unrecoverable: ${undef?message}`; `pipeline #Initial value of PIPESTATUS is empty string`; `sh-options #$- with pipefail`; `vars-bash #$SHELL is set to what is in /etc/passwd`; `vars-special #$HOME is NOT set` |
 | Host files, processes and signals | 37 | Need host `PATH` programs or `$REPO_ROOT` files the VFS cannot see, real processes, job specs, signals from another process, `ulimit` on real fds, hard links, exec bits or `umask` applied by the host kernel (L-SIG-001, L-PROC-002, L-FS-001, L-FS-002, L-ROOTFS-001) | `assign #Escaped = in command name`; `assign-extended #declare -F with shopt -s extdebug and main file`; `assign-extended #declare -F with shopt -s extdebug prints more info`; `background #Signal message for killed background job`; `background #Start background pipeline, wait %job_spec`; `background #Wait for job and PIPESTATUS`; `background #Wait for job and PIPESTATUS - cat`; `background #wait -n with arguments - arguments are respected`; `background #wait for N parallel jobs and check failure`; `background #wait with invalid arg`; `bugs #'echo' and printf fail on writing to full disk`; `bugs #other builtins fail on writing to full disk`; `builtin-bracket #-ef`; `builtin-cd #pwd in symlinked dir on shell initialization`; `builtin-meta #command -p (hide tool in custom path)`; `builtin-meta #command -p (override existing program)`; `builtin-meta #command -v doesn't find non-executable file`; `builtin-process #ulimit -n limits file descriptors`; `builtin-trap #exit codes for traps are isolated`; `builtin-trap #trap EXIT, sleep, SIGINT: non-interactively`; `builtin-trap #trap USR1, sleep, SIGINT: non-interactively`; `builtin-trap #traps are cleared in subshell (started with &)`; `builtin-trap-bash #Combine DEBUG trap and USR1 trap`; `builtin-trap-bash #Combine ERR trap and USR1 trap`; `builtin-type #type of relative path`; `builtin-umask #'umask 0002' sets the umask`; `builtin-umask #set umask with symbolic mode: g-w,o-w`; `divergence #builtin cat crashes a subshell (#2530)`; `glob #glob can expand to command and arg`; `history-expand #!! expansion`; `process-sub #Process sub from shell to stdin`; `redirect #<> for read/write named pipes`; `sh-options #interactive shell starts with emacs mode on`; `sh-options #noclobber on <>`; `sh-usage #LC_CTYPE=invalid`; `sh-usage #Set LC_ALL LC_CTYPE LC_COLLATE LANG - affects glob ?`; `var-op-patsub #When LC_ALL=C, pattern ? doesn't match multibyte character` |
 | Bytes that are not UTF-8 (L-STREAM-001) | 8 | Words and variables are text; `\377` and invalid sequences become U+FFFD | `bugs #file with NUL byte`; `builtin-printf #printf octal backslash escapes`; `quote #$'' octal escapes don't have leading 0`; `serialize #printf %q invalid unicode`; `serialize #printf %q unprintable`; `unicode #OSH source code doesn't have to be valid Unicode (like other shells)`; `var-op-len #String length with incomplete utf-8`; `var-op-len #String length with invalid utf-8 continuation bytes` |
-| Out of scope by design | 11 | ERR trap combinations are a separate track; `$(...)` read from data into arithmetic stays refused (L-ARITH-001); ble.sh's recursive arithmetic passes the 50-level cap (TM-DOS-026) | `array-assign #LHS array is protected with shopt -s eval_unsafe_arith, e.g. 'a[$(echo 2)]'`; `ble-idioms #recursive arith: recursion`; `bugs #command execution $(echo 42 \| tee PWNED) not allowed`; `bugs #unset doesn't allow command execution`; `builtin-trap-bash #Combine DEBUG trap and ERR trap`; `builtin-trap-err #set -o errtrace: trap ERR with &`; `builtin-trap-err #trap ERR pipelines without simple commands`; `builtin-trap-err #trap ERR with "atoms": assignment (( [[`; `nameref #a[expr] in nameref`; `var-ref #Var Ref Code Injection $(tee PWNED)`; `var-ref #var ref TO array with arbitrary subscripts` |
+| Out of scope by design | 10 | ERR trap combinations are a separate track; `$(...)` read from data into arithmetic stays refused (L-ARITH-001); ble.sh's recursive arithmetic passes the 50-level cap (TM-DOS-026) | `array-assign #LHS array is protected with shopt -s eval_unsafe_arith, e.g. 'a[$(echo 2)]'`; `ble-idioms #recursive arith: recursion`; `bugs #command execution $(echo 42 \| tee PWNED) not allowed`; `bugs #unset doesn't allow command execution`; `builtin-trap-bash #Combine DEBUG trap and ERR trap`; `builtin-trap-err #set -o errtrace: trap ERR with &`; `builtin-trap-err #trap ERR pipelines without simple commands`; `nameref #a[expr] in nameref`; `var-ref #Var Ref Code Injection $(tee PWNED)`; `var-ref #var ref TO array with arbitrary subscripts` |
 | Bash bugs or quirks Oils pins | 7 | bash 5.2 behavior that Oils marks as a bug or that depends on bash internals (a moved fd not restored, `read` and `mapfile` on a directory, brace expansion of a var-only item, mixed-case char ranges, `[^]]` in patsub) | `brace-expansion #Mixed case char expansion is invalid`; `brace-expansion #double expansion with literal and simple var`; `brace-expansion #double expansion with simple var -- bash bug`; `builtin-read #mapfile from directory (bash doesn't handle errors)`; `builtin-read #read bash bug`; `redirect #1>&2- (Bash bug: fail to restore closed fd)`; `var-op-patsub #patsub with [^]]` |
-| Aliases expanded per command, not per line | 9 | bashkit parses the whole input before expanding aliases, so an alias defined on the same line, an alias for `{`/`(`, a here-doc or loop split across aliases, and `{ls;\n}` / `failglob` on one line do not match bash's line-by-line reading | `alias #Alias can be defined and used on a single line`; `alias #Loop split across alias in another way`; `alias #Loop split across both iterative and recursive aliases`; `alias #alias for left brace`; `alias #alias for left paren`; `alias #define and use alias on a single line`; `alias #here doc inside alias`; `glob-bash #shopt -s failglob behavior on single line with semicolon`; `parse-errors #} on the second line` |
-| Parser gaps | 9 | Constructs bashkit's parser reads differently: `a[` with no `]` as a command word, a nested array literal, `for ((;;)) { }`, `for i` with `in` on the next line, a redirect on `(( ))`, `!(` without `extglob`, and extglob words (`$*@(...)`, `[+()]`, `[[ !(x) ]]` before `shopt -s extglob`) | `array-assign #More fragments like a[  a[5  a[5 +  a[5 + 3]`; `divergence #!( as negation and subshell versus extended glob - #2463`; `dparen #(( )) with redirect`; `extglob-files #Extended glob in same word as array`; `extglob-match #Turning extglob on changes the meaning of [[ !(str) ]] in bash`; `for-expr #Accepts { } syntax too`; `parse-errors #array literal inside array is a parse error`; `toysh #char class / extglob`; `toysh-posix #for loop parsing - http://landley.net/notes.html#04-03-2020` |
-| Globbing gaps | 6 | `shopt -u globskipdots` and `GLOBIGNORE=.:..` never list `.`/`..` (the VFS read_dir has no such entries), a no-match extglob prints its pattern with escapes, `[C\-D]` in a pathname glob holds no literal `-` (it does in `case` and `[[ ]]`), and `failglob` in an array literal | `extglob-files #no match`; `extglob-files #noglob`; `glob #glob with escaped - in char class`; `glob #shopt -u globskipdots shows . and ..`; `glob-bash #shopt -s failglob in array literal context`; `globignore #Ignore .:..` |
-| Arrays and namerefs | 8 | `${a[b=2]}` evaluates read subscripts without assignment, a temporary `a[0 + 1]=x cmd` element persists, `assoc["${a[@]}"]` does not join, `builtin`/`command` before `declare a=(..)` is not a declaration, `ref=(..)` through `declare -n ref='a[@]'` is not refused, and ble.sh's `eval` array shift idiom | `arith #Side Effect in Array Indexing`; `array-assign #Multiple LHS array words`; `array-assoc #Indexed array as key of associative array coerces to string (without shopt -s strict_array)`; `assign-deferred #is 'builtin' prefix and array allowed?  OSH is smarter`; `assign-deferred #is 'command' prefix and array allowed?  OSH is smarter`; `ble-idioms #shift unshift reverse`; `builtin-meta-assign #builtin declare a=(x y) is allowed`; `nameref #a[@] in nameref` |
-| Other open gaps | 13 | `$LINENO` of `(( ))`/`[[ ]]` needs a span on those AST nodes (the serialized snapshot fixtures pin the AST shape); `set -v` / `bash -v` echo nothing; `compgen -A builtin` lists bashkit's whole builtin registry; tilde in `${undef-~:~}` inside an assignment; `[[ $HOME =~ ~ ]]` quoting; `set -e` inside a function called under `!`; a function's redirect is expanded after its body runs, not before; `1>& "$@"` with several words; a nested `${a:-${a:-"1 2" "3 4"}5}` field tree; `unset` of a dynamic local from a subshell | `ble-unset #[bash_unset] local-unset / dynamic-unset for localvar on nested-context`; `builtin-completion #compgen -A builtin`; `builtin-trap-bash #trap DEBUG with non-compound commands`; `dbracket #tilde expansion with =~ (confusing)`; `errexit #set -e in function #2`; `redirect-command #Redirect in function body is evaluated multiple times`; `sh-usage #sh - and sh -- stop flag processing`; `tilde #x=${undef-~:~}`; `var-sub #Descriptor redirect to bad "$@"`; `var-sub-quote #part_value tree with multiple words`; `vars-special #$LINENO in ((`; `xtrace #set -o verbose prints unevaluated code`; `ysh-builtin-private #compgen -A builtin doesn't find private builtins` |
+| Parser gaps | 2 | Constructs bashkit's parser reads differently: a nested array literal is a fatal parse error (bash reports it and runs on with status 1), and a quoted `]` inside an unterminated-looking bracket word (`[hello"]"`) is still read as a glob class | `parse-errors #array literal inside array is a parse error`; `toysh #char class / extglob` |
+| Arrays and namerefs | 2 | `assoc["${a[@]}"]` as a read subscript is evaluated as arithmetic instead of joining the words, and `ref=(..)` through `declare -n ref='a[@]'` is not refused | `array-assoc #Indexed array as key of associative array coerces to string (without shopt -s strict_array)`; `nameref #a[@] in nameref` |
+| Other open gaps | 2 | A nested `${a:-${a:-"1 2" "3 4"}5}` field tree; `unset` of a dynamic local from a subshell | `ble-unset #[bash_unset] local-unset / dynamic-unset for localvar on nested-context`; `var-sub-quote #part_value tree with multiple words` |
 
 ## Lifting a Limitation / Adding One
 
diff --git a/knowledge/operations/oils-spec.md b/knowledge/operations/oils-spec.md
index f06cc516e..5f0845da9 100644
--- a/knowledge/operations/oils-spec.md
+++ b/knowledge/operations/oils-spec.md
@@ -17,15 +17,20 @@ Implemented. Harness: `scripts/oils-spec/run.py` (`just oils-spec`).
 
 ## Headline
 
-**95.8%**: bashkit passes 2578 of the 2692 Oils spec cases real bash 5.2.21
-passes (2759 cases in 132 spec files; bashkit passes 2588 of all cases,
-93.8%). Oils `57d3f0d088c3`, 2026-10-08. Report:
-`scripts/oils-spec/results/oils-spec-linux-x86_64-20261008T225033Z.md`
+**97.3%**: bashkit passes 2618 of the 2692 Oils spec cases real bash 5.2.21
+passes (2759 cases in 132 spec files; bashkit passes 2628 of all cases,
+95.3%). Oils `57d3f0d088c3`, 2026-10-09. Report:
+`scripts/oils-spec/results/oils-spec-linux-x86_64-20261009T010244Z.md`
 (bash missed one timing-dependent `builtin-kill` case in this run that
 bashkit passes, hence 2692).
 Every remaining miss is listed by cause under "Oils Spec Misses" in
 [Known Limitations](limitations.md).
-The run before this one (92.8%, `...T211202Z.md`) missed 9 in
+The run before this one (95.8%, `...T225033Z.md`) missed 7 in `alias`, 3 in
+`extglob-files`, `array-assign` and `glob`, 2 in `assign-deferred`,
+`glob-bash`, `ble-idioms` and `parse-errors`; they now miss 0, 0, 1, 1, 0,
+0, 1 and 1. 19 files went to 0 in that change, 40 cases in all, with no new
+misses.
+The run before that (92.8%, `...T211202Z.md`) missed 9 in
 `ysh-builtin-private`, 7 in `arith` and `array-literal`, 5 in `nameref`, 4
 in `array`, `array-assoc`, `var-sub-quote` and `parse-errors`, 3 in
 `blog2`, `bool-parse`, `builtin-misc` and `func-parsing`; they now miss 1,
diff --git a/scripts/oils-spec/results/oils-spec-linux-x86_64-20261009T010244Z.json b/scripts/oils-spec/results/oils-spec-linux-x86_64-20261009T010244Z.json
new file mode 100644
index 000000000..8eda57035
--- /dev/null
+++ b/scripts/oils-spec/results/oils-spec-linux-x86_64-20261009T010244Z.json
@@ -0,0 +1,2330 @@
+{
+ "schema": 1,
+ "oils_repo": "https://github.com/oils-for-unix/oils",
+ "oils_rev": "57d3f0d088c36340bc4b3038208e58ea02acf15c",
+ "bashkit_commit": "298bf8f9cfd1",
+ "bash_version": "5.2.21(1)-release",
+ "timestamp": "2026-10-09T01:02:44Z",
+ "platform": "linux-x86_64",
+ "jobs": 4,
+ "timeout_secs": 10,
+ "elapsed_secs": 21.4,
+ "files_run": 132,
+ "files_skipped": 91,
+ "total": {
+  "cases": 2759,
+  "bashkit_pass": 2628,
+  "bashkit_pass_pct": 95.3,
+  "bash_pass": 2692,
+  "bash_pass_pct": 97.6,
+  "bashkit_pass_of_bash": 2618,
+  "pass_rate": 97.3
+ },
+ "failure_classes": {
+  "behavior": 48,
+  "processes": 10,
+  "signals": 5,
+  "host": 7,
+  "interactive": 4
+ },
+ "files": {
+  "background": {
+   "summary": {
+    "cases": 27,
+    "bashkit_pass": 20,
+    "bashkit_pass_pct": 74.1,
+    "bash_pass": 27,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 20,
+    "pass_rate": 74.1
+   },
+   "missed": [
+    {
+     "case": 1,
+     "name": "wait -n with arguments - arguments are respected",
+     "class": "processes",
+     "on": "stdout"
+    },
+    {
+     "case": 5,
+     "name": "wait with invalid arg",
+     "class": "processes",
+     "on": "status"
+    },
+    {
+     "case": 7,
+     "name": "wait for N parallel jobs and check failure",
+     "class": "processes",
+     "on": "stdout"
+    },
+    {
+     "case": 11,
+     "name": "Start background pipeline, wait %job_spec",
+     "class": "processes",
+     "on": "stdout"
+    },
+    {
+     "case": 12,
+     "name": "Wait for job and PIPESTATUS",
+     "class": "processes",
+     "on": "stdout"
+    },
+    {
+     "case": 13,
+     "name": "Wait for job and PIPESTATUS - cat",
+     "class": "processes",
+     "on": "stdout"
+    },
+    {
+     "case": 26,
+     "name": "Signal message for killed background job",
+     "class": "signals",
+     "on": "stdout"
+    }
+   ],
+   "bash_fails": []
+  },
+  "bugs": {
+   "summary": {
+    "cases": 29,
+    "bashkit_pass": 24,
+    "bashkit_pass_pct": 82.8,
+    "bash_pass": 29,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 24,
+    "pass_rate": 82.8
+   },
+   "missed": [
+    {
+     "case": 10,
+     "name": "file with NUL byte",
+     "class": "behavior",
+     "on": "stdout"
+    },
+    {
+     "case": 12,
+     "name": "'echo' and printf fail on writing to full disk",
+     "class": "behavior",
+     "on": "stdout"
+    },
+    {
+     "case": 13,
+     "name": "other builtins fail on writing to full disk",
+     "class": "processes",
+     "on": "stdout"
+    },
+    {
+     "case": 19,
+     "name": "command execution $(echo 42 | tee PWNED) not allowed",
+     "class": "behavior",
+     "on": "stdout"
+    },
+    {
+     "case": 21,
+     "name": "unset doesn't allow command execution",
+     "class": "behavior",
+     "on": "stdout"
+    }
+   ],
+   "bash_fails": []
+  },
+  "builtin-trap": {
+   "summary": {
+    "cases": 33,
+    "bashkit_pass": 29,
+    "bashkit_pass_pct": 87.9,
+    "bash_pass": 33,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 29,
+    "pass_rate": 87.9
+   },
+   "missed": [
+    {
+     "case": 24,
+     "name": "exit codes for traps are isolated",
+     "class": "signals",
+     "on": "stdout"
+    },
+    {
+     "case": 25,
+     "name": "traps are cleared in subshell (started with &)",
+     "class": "signals",
+     "on": "stdout"
+    },
+    {
+     "case": 26,
+     "name": "trap USR1, sleep, SIGINT: non-interactively",
+     "class": "behavior",
+     "on": "stdout"
+    },
+    {
+     "case": 28,
+     "name": "trap EXIT, sleep, SIGINT: non-interactively",
+     "class": "behavior",
+     "on": "stdout"
+    }
+   ],
+   "bash_fails": []
+  },
+  "brace-expansion": {
+   "summary": {
+    "cases": 55,
+    "bashkit_pass": 52,
+    "bashkit_pass_pct": 94.5,
+    "bash_pass": 55,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 52,
+    "pass_rate": 94.5
+   },
+   "missed": [
+    {
+     "case": 11,
+     "name": "double expansion with simple var -- bash bug",
+     "class": "behavior",
+     "on": "stdout"
+    },
+    {
+     "case": 13,
+     "name": "double expansion with literal and simple var",
+     "class": "behavior",
+     "on": "stdout"
+    },
+    {
+     "case": 42,
+     "name": "Mixed case char expansion is invalid",
+     "class": "behavior",
+     "on": "stdout"
+    }
+   ],
+   "bash_fails": []
+  },
+  "builtin-meta": {
+   "summary": {
+    "cases": 18,
+    "bashkit_pass": 15,
+    "bashkit_pass_pct": 83.3,
+    "bash_pass": 18,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 15,
+    "pass_rate": 83.3
+   },
+   "missed": [
+    {
+     "case": 3,
+     "name": "command -v doesn't find non-executable file",
+     "class": "host",
+     "on": "stdout"
+    },
+    {
+     "case": 10,
+     "name": "command -p (override existing program)",
+     "class": "host",
+     "on": "stdout"
+    },
+    {
+     "case": 11,
+     "name": "command -p (hide tool in custom path)",
+     "class": "host",
+     "on": "status"
+    }
+   ],
+   "bash_fails": []
+  },
+  "builtin-trap-bash": {
+   "summary": {
+    "cases": 23,
+    "bashkit_pass": 20,
+    "bashkit_pass_pct": 87.0,
+    "bash_pass": 23,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 20,
+    "pass_rate": 87.0
+   },
+   "missed": [
+    {
+     "case": 20,
+     "name": "Combine DEBUG trap and USR1 trap",
+     "class": "signals",
+     "on": "stdout"
+    },
+    {
+     "case": 21,
+     "name": "Combine ERR trap and USR1 trap",
+     "class": "signals",
+     "on": "stdout"
+    },
+    {
+     "case": 22,
+     "name": "Combine DEBUG trap and ERR trap",
+     "class": "behavior",
+     "on": "stdout"
+    }
+   ],
+   "bash_fails": []
+  },
+  "sh-options": {
+   "summary": {
+    "cases": 39,
+    "bashkit_pass": 36,
+    "bashkit_pass_pct": 92.3,
+    "bash_pass": 39,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 36,
+    "pass_rate": 92.3
+   },
+   "missed": [
+    {
+     "case": 1,
+     "name": "$- with pipefail",
+     "class": "behavior",
+     "on": "stdout"
+    },
+    {
+     "case": 9,
+     "name": "interactive shell starts with emacs mode on",
+     "class": "interactive",
+     "on": "stdout"
+    },
+    {
+     "case": 20,
+     "name": "noclobber on <>",
+     "class": "behavior",
+     "on": "stdout"
+    }
+   ],
+   "bash_fails": []
+  },
+  "assign-extended": {
+   "summary": {
+    "cases": 39,
+    "bashkit_pass": 33,
+    "bashkit_pass_pct": 84.6,
+    "bash_pass": 35,
+    "bash_pass_pct": 89.7,
+    "bashkit_pass_of_bash": 33,
+    "pass_rate": 94.3
+   },
+   "missed": [
+    {
+     "case": 4,
+     "name": "declare -F with shopt -s extdebug prints more info",
+     "class": "behavior",
+     "on": "stdout"
+    },
+    {
+     "case": 5,
+     "name": "declare -F with shopt -s extdebug and main file",
+     "class": "behavior",
+     "on": "stdout"
+    }
+   ],
+   "bash_fails": [
+    7,
+    8,
+    10,
+    11
+   ]
+  },
+  "builtin-read": {
+   "summary": {
+    "cases": 64,
+    "bashkit_pass": 62,
+    "bashkit_pass_pct": 96.9,
+    "bash_pass": 64,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 62,
+    "pass_rate": 96.9
+   },
+   "missed": [
+    {
+     "case": 48,
+     "name": "mapfile from directory (bash doesn't handle errors)",
+     "class": "behavior",
+     "on": "stdout"
+    },
+    {
+     "case": 63,
+     "name": "read bash bug",
+     "class": "behavior",
+     "on": "stdout"
+    }
+   ],
+   "bash_fails": []
+  },
+  "builtin-trap-err": {
+   "summary": {
+    "cases": 23,
+    "bashkit_pass": 20,
+    "bashkit_pass_pct": 87.0,
+    "bash_pass": 22,
+    "bash_pass_pct": 95.7,
+    "bashkit_pass_of_bash": 20,
+    "pass_rate": 90.9
+   },
+   "missed": [
+    {
+     "case": 6,
+     "name": "trap ERR pipelines without simple commands",
+     "class": "behavior",
+     "on": "stdout"
+    },
+    {
+     "case": 12,
+     "name": "set -o errtrace: trap ERR with &",
+     "class": "processes",
+     "on": "stdout"
+    }
+   ],
+   "bash_fails": [
+    18
+   ]
+  },
+  "builtin-umask": {
+   "summary": {
+    "cases": 24,
+    "bashkit_pass": 22,
+    "bashkit_pass_pct": 91.7,
+    "bash_pass": 24,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 22,
+    "pass_rate": 91.7
+   },
+   "missed": [
+    {
+     "case": 10,
+     "name": "'umask 0002' sets the umask",
+     "class": "host",
+     "on": "stdout"
+    },
+    {
+     "case": 11,
+     "name": "set umask with symbolic mode: g-w,o-w",
+     "class": "host",
+     "on": "stdout"
+    }
+   ],
+   "bash_fails": []
+  },
+  "fatal-errors": {
+   "summary": {
+    "cases": 5,
+    "bashkit_pass": 3,
+    "bashkit_pass_pct": 60.0,
+    "bash_pass": 5,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 3,
+    "pass_rate": 60.0
+   },
+   "missed": [
+    {
+     "case": 3,
+     "name": "Unrecoverable: ${undef?message}",
+     "class": "behavior",
+     "on": "stdout"
+    },
+    {
+     "case": 4,
+     "name": "${undef} with nounset",
+     "class": "behavior",
+     "on": "stdout"
+    }
+   ],
+   "bash_fails": []
+  },
+  "nameref": {
+   "summary": {
+    "cases": 32,
+    "bashkit_pass": 30,
+    "bashkit_pass_pct": 93.8,
+    "bash_pass": 32,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 30,
+    "pass_rate": 93.8
+   },
+   "missed": [
+    {
+     "case": 26,
+     "name": "a[expr] in nameref",
+     "class": "behavior",
+     "on": "stdout"
+    },
+    {
+     "case": 27,
+     "name": "a[@] in nameref",
+     "class": "behavior",
+     "on": "stdout"
+    }
+   ],
+   "bash_fails": []
+  },
+  "redirect": {
+   "summary": {
+    "cases": 41,
+    "bashkit_pass": 39,
+    "bashkit_pass_pct": 95.1,
+    "bash_pass": 41,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 39,
+    "pass_rate": 95.1
+   },
+   "missed": [
+    {
+     "case": 27,
+     "name": "1>&2- (Bash bug: fail to restore closed fd)",
+     "class": "processes",
+     "on": "stdout"
+    },
+    {
+     "case": 29,
+     "name": "<> for read/write named pipes",
+     "class": "host",
+     "on": "stdout"
+    }
+   ],
+   "bash_fails": []
+  },
+  "serialize": {
+   "summary": {
+    "cases": 10,
+    "bashkit_pass": 8,
+    "bashkit_pass_pct": 80.0,
+    "bash_pass": 10,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 8,
+    "pass_rate": 80.0
+   },
+   "missed": [
+    {
+     "case": 3,
+     "name": "printf %q unprintable",
+     "class": "behavior",
+     "on": "stdout"
+    },
+    {
+     "case": 5,
+     "name": "printf %q invalid unicode",
+     "class": "behavior",
+     "on": "stdout"
+    }
+   ],
+   "bash_fails": []
+  },
+  "sh-usage": {
+   "summary": {
+    "cases": 24,
+    "bashkit_pass": 22,
+    "bashkit_pass_pct": 91.7,
+    "bash_pass": 24,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 22,
+    "pass_rate": 91.7
+   },
+   "missed": [
+    {
+     "case": 15,
+     "name": "Set LC_ALL LC_CTYPE LC_COLLATE LANG - affects glob ?",
+     "class": "behavior",
+     "on": "stdout"
+    },
+    {
+     "case": 16,
+     "name": "LC_CTYPE=invalid",
+     "class": "behavior",
+     "on": "stdout"
+    }
+   ],
+   "bash_fails": []
+  },
+  "var-op-len": {
+   "summary": {
+    "cases": 9,
+    "bashkit_pass": 7,
+    "bashkit_pass_pct": 77.8,
+    "bash_pass": 8,
+    "bash_pass_pct": 88.9,
+    "bashkit_pass_of_bash": 6,
+    "pass_rate": 75.0
+   },
+   "missed": [
+    {
+     "case": 3,
+     "name": "String length with incomplete utf-8",
+     "class": "behavior",
+     "on": "stdout"
+    },
+    {
+     "case": 4,
+     "name": "String length with invalid utf-8 continuation bytes",
+     "class": "behavior",
+     "on": "stdout"
+    }
+   ],
+   "bash_fails": [
+    8
+   ]
+  },
+  "var-op-patsub": {
+   "summary": {
+    "cases": 28,
+    "bashkit_pass": 26,
+    "bashkit_pass_pct": 92.9,
+    "bash_pass": 28,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 26,
+    "pass_rate": 92.9
+   },
+   "missed": [
+    {
+     "case": 19,
+     "name": "When LC_ALL=C, pattern ? doesn't match multibyte character",
+     "class": "behavior",
+     "on": "stdout"
+    },
+    {
+     "case": 23,
+     "name": "patsub with [^]]",
+     "class": "behavior",
+     "on": "stdout"
+    }
+   ],
+   "bash_fails": []
+  },
+  "var-ref": {
+   "summary": {
+    "cases": 31,
+    "bashkit_pass": 28,
+    "bashkit_pass_pct": 90.3,
+    "bash_pass": 30,
+    "bash_pass_pct": 96.8,
+    "bashkit_pass_of_bash": 28,
+    "pass_rate": 93.3
+   },
+   "missed": [
+    {
+     "case": 19,
+     "name": "var ref TO array with arbitrary subscripts",
+     "class": "behavior",
+     "on": "stdout"
+    },
+    {
+     "case": 26,
+     "name": "Var Ref Code Injection $(tee PWNED)",
+     "class": "behavior",
+     "on": "stdout"
+    }
+   ],
+   "bash_fails": [
+    12
+   ]
+  },
+  "array-assign": {
+   "summary": {
+    "cases": 11,
+    "bashkit_pass": 10,
+    "bashkit_pass_pct": 90.9,
+    "bash_pass": 11,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 10,
+    "pass_rate": 90.9
+   },
+   "missed": [
+    {
+     "case": 4,
+     "name": "LHS array is protected with shopt -s eval_unsafe_arith, e.g. 'a[$(echo 2)]'",
+     "class": "behavior",
+     "on": "stdout"
+    }
+   ],
+   "bash_fails": []
+  },
+  "array-assoc": {
+   "summary": {
+    "cases": 42,
+    "bashkit_pass": 35,
+    "bashkit_pass_pct": 83.3,
+    "bash_pass": 36,
+    "bash_pass_pct": 85.7,
+    "bashkit_pass_of_bash": 35,
+    "pass_rate": 97.2
+   },
+   "missed": [
+    {
+     "case": 19,
+     "name": "Indexed array as key of associative array coerces to string (without shopt -s strict_array)",
+     "class": "behavior",
+     "on": "stdout"
+    }
+   ],
+   "bash_fails": [
+    1,
+    2,
+    21,
+    26,
+    34,
+    41
+   ]
+  },
+  "assign": {
+   "summary": {
+    "cases": 48,
+    "bashkit_pass": 44,
+    "bashkit_pass_pct": 91.7,
+    "bash_pass": 45,
+    "bash_pass_pct": 93.8,
+    "bashkit_pass_of_bash": 44,
+    "pass_rate": 97.8
+   },
+   "missed": [
+    {
+     "case": 8,
+     "name": "Escaped = in command name",
+     "class": "behavior",
+     "on": "stdout"
+    }
+   ],
+   "bash_fails": [
+    24,
+    27,
+    46
+   ]
+  },
+  "ble-idioms": {
+   "summary": {
+    "cases": 26,
+    "bashkit_pass": 25,
+    "bashkit_pass_pct": 96.2,
+    "bash_pass": 26,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 25,
+    "pass_rate": 96.2
+   },
+   "missed": [
+    {
+     "case": 5,
+     "name": "recursive arith: recursion",
+     "class": "behavior",
+     "on": "stdout"
+    }
+   ],
+   "bash_fails": []
+  },
+  "ble-unset": {
+   "summary": {
+    "cases": 5,
+    "bashkit_pass": 4,
+    "bashkit_pass_pct": 80.0,
+    "bash_pass": 5,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 4,
+    "pass_rate": 80.0
+   },
+   "missed": [
+    {
+     "case": 1,
+     "name": "[bash_unset] local-unset / dynamic-unset for localvar on nested-context",
+     "class": "behavior",
+     "on": "stdout"
+    }
+   ],
+   "bash_fails": []
+  },
+  "builtin-bracket": {
+   "summary": {
+    "cases": 52,
+    "bashkit_pass": 49,
+    "bashkit_pass_pct": 94.2,
+    "bash_pass": 50,
+    "bash_pass_pct": 96.2,
+    "bashkit_pass_of_bash": 49,
+    "pass_rate": 98.0
+   },
+   "missed": [
+    {
+     "case": 41,
+     "name": "-ef",
+     "class": "behavior",
+     "on": "stdout"
+    }
+   ],
+   "bash_fails": [
+    25,
+    26
+   ]
+  },
+  "builtin-cd": {
+   "summary": {
+    "cases": 30,
+    "bashkit_pass": 27,
+    "bashkit_pass_pct": 90.0,
+    "bash_pass": 28,
+    "bash_pass_pct": 93.3,
+    "bashkit_pass_of_bash": 27,
+    "pass_rate": 96.4
+   },
+   "missed": [
+    {
+     "case": 14,
+     "name": "pwd in symlinked dir on shell initialization",
+     "class": "behavior",
+     "on": "stdout"
+    }
+   ],
+   "bash_fails": [
+    24,
+    25
+   ]
+  },
+  "builtin-printf": {
+   "summary": {
+    "cases": 63,
+    "bashkit_pass": 60,
+    "bashkit_pass_pct": 95.2,
+    "bash_pass": 58,
+    "bash_pass_pct": 92.1,
+    "bashkit_pass_of_bash": 57,
+    "pass_rate": 98.3
+   },
+   "missed": [
+    {
+     "case": 33,
+     "name": "printf octal backslash escapes",
+     "class": "behavior",
+     "on": "stdout"
+    }
+   ],
+   "bash_fails": [
+    26,
+    27,
+    46,
+    47,
+    48
+   ]
+  },
+  "builtin-process": {
+   "summary": {
+    "cases": 26,
+    "bashkit_pass": 24,
+    "bashkit_pass_pct": 92.3,
+    "bash_pass": 24,
+    "bash_pass_pct": 92.3,
+    "bashkit_pass_of_bash": 23,
+    "pass_rate": 95.8
+   },
+   "missed": [
+    {
+     "case": 25,
+     "name": "ulimit -n limits file descriptors",
+     "class": "processes",
+     "on": "stdout"
+    }
+   ],
+   "bash_fails": [
+    9,
+    22
+   ]
+  },
+  "builtin-type": {
+   "summary": {
+    "cases": 6,
+    "bashkit_pass": 5,
+    "bashkit_pass_pct": 83.3,
+    "bash_pass": 6,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 5,
+    "pass_rate": 83.3
+   },
+   "missed": [
+    {
+     "case": 2,
+     "name": "type of relative path",
+     "class": "host",
+     "on": "stdout"
+    }
+   ],
+   "bash_fails": []
+  },
+  "divergence": {
+   "summary": {
+    "cases": 4,
+    "bashkit_pass": 3,
+    "bashkit_pass_pct": 75.0,
+    "bash_pass": 4,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 3,
+    "pass_rate": 75.0
+   },
+   "missed": [
+    {
+     "case": 3,
+     "name": "builtin cat crashes a subshell (#2530)",
+     "class": "behavior",
+     "on": "stdout"
+    }
+   ],
+   "bash_fails": []
+  },
+  "glob": {
+   "summary": {
+    "cases": 39,
+    "bashkit_pass": 36,
+    "bashkit_pass_pct": 92.3,
+    "bash_pass": 37,
+    "bash_pass_pct": 94.9,
+    "bashkit_pass_of_bash": 36,
+    "pass_rate": 97.3
+   },
+   "missed": [
+    {
+     "case": 7,
+     "name": "glob can expand to command and arg",
+     "class": "behavior",
+     "on": "stdout"
+    }
+   ],
+   "bash_fails": [
+    23,
+    31
+   ]
+  },
+  "history-expand": {
+   "summary": {
+    "cases": 1,
+    "bashkit_pass": 0,
+    "bashkit_pass_pct": 0.0,
+    "bash_pass": 1,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 0,
+    "pass_rate": 0.0
+   },
+   "missed": [
+    {
+     "case": 0,
+     "name": "!! expansion",
+     "class": "interactive",
+     "on": "stdout"
+    }
+   ],
+   "bash_fails": []
+  },
+  "parse-errors": {
+   "summary": {
+    "cases": 27,
+    "bashkit_pass": 24,
+    "bashkit_pass_pct": 88.9,
+    "bash_pass": 25,
+    "bash_pass_pct": 92.6,
+    "bashkit_pass_of_bash": 24,
+    "pass_rate": 96.0
+   },
+   "missed": [
+    {
+     "case": 22,
+     "name": "array literal inside array is a parse error",
+     "class": "behavior",
+     "on": "stdout"
+    }
+   ],
+   "bash_fails": [
+    0,
+    1
+   ]
+  },
+  "pipeline": {
+   "summary": {
+    "cases": 26,
+    "bashkit_pass": 24,
+    "bashkit_pass_pct": 92.3,
+    "bash_pass": 25,
+    "bash_pass_pct": 96.2,
+    "bashkit_pass_of_bash": 24,
+    "pass_rate": 96.0
+   },
+   "missed": [
+    {
+     "case": 6,
+     "name": "Initial value of PIPESTATUS is empty string",
+     "class": "behavior",
+     "on": "stdout"
+    }
+   ],
+   "bash_fails": [
+    10
+   ]
+  },
+  "process-sub": {
+   "summary": {
+    "cases": 9,
+    "bashkit_pass": 8,
+    "bashkit_pass_pct": 88.9,
+    "bash_pass": 8,
+    "bash_pass_pct": 88.9,
+    "bashkit_pass_of_bash": 7,
+    "pass_rate": 87.5
+   },
+   "missed": [
+    {
+     "case": 2,
+     "name": "Process sub from shell to stdin",
+     "class": "behavior",
+     "on": "stdout"
+    }
+   ],
+   "bash_fails": [
+    4
+   ]
+  },
+  "quote": {
+   "summary": {
+    "cases": 35,
+    "bashkit_pass": 34,
+    "bashkit_pass_pct": 97.1,
+    "bash_pass": 35,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 34,
+    "pass_rate": 97.1
+   },
+   "missed": [
+    {
+     "case": 27,
+     "name": "$'' octal escapes don't have leading 0",
+     "class": "behavior",
+     "on": "stdout"
+    }
+   ],
+   "bash_fails": []
+  },
+  "toysh": {
+   "summary": {
+    "cases": 8,
+    "bashkit_pass": 7,
+    "bashkit_pass_pct": 87.5,
+    "bash_pass": 8,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 7,
+    "pass_rate": 87.5
+   },
+   "missed": [
+    {
+     "case": 3,
+     "name": "char class / extglob",
+     "class": "behavior",
+     "on": "stdout"
+    }
+   ],
+   "bash_fails": []
+  },
+  "unicode": {
+   "summary": {
+    "cases": 7,
+    "bashkit_pass": 1,
+    "bashkit_pass_pct": 14.3,
+    "bash_pass": 2,
+    "bash_pass_pct": 28.6,
+    "bashkit_pass_of_bash": 1,
+    "pass_rate": 50.0
+   },
+   "missed": [
+    {
+     "case": 0,
+     "name": "OSH source code doesn't have to be valid Unicode (like other shells)",
+     "class": "behavior",
+     "on": "stdout"
+    }
+   ],
+   "bash_fails": [
+    2,
+    3,
+    4,
+    5,
+    6
+   ]
+  },
+  "var-sub-quote": {
+   "summary": {
+    "cases": 41,
+    "bashkit_pass": 40,
+    "bashkit_pass_pct": 97.6,
+    "bash_pass": 41,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 40,
+    "pass_rate": 97.6
+   },
+   "missed": [
+    {
+     "case": 18,
+     "name": "part_value tree with multiple words",
+     "class": "behavior",
+     "on": "stdout"
+    }
+   ],
+   "bash_fails": []
+  },
+  "vars-bash": {
+   "summary": {
+    "cases": 1,
+    "bashkit_pass": 0,
+    "bashkit_pass_pct": 0.0,
+    "bash_pass": 1,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 0,
+    "pass_rate": 0.0
+   },
+   "missed": [
+    {
+     "case": 0,
+     "name": "$SHELL is set to what is in /etc/passwd",
+     "class": "interactive",
+     "on": "stdout"
+    }
+   ],
+   "bash_fails": []
+  },
+  "vars-special": {
+   "summary": {
+    "cases": 42,
+    "bashkit_pass": 39,
+    "bashkit_pass_pct": 92.9,
+    "bash_pass": 40,
+    "bash_pass_pct": 95.2,
+    "bashkit_pass_of_bash": 39,
+    "pass_rate": 97.5
+   },
+   "missed": [
+    {
+     "case": 3,
+     "name": "$HOME is NOT set",
+     "class": "interactive",
+     "on": "stdout"
+    }
+   ],
+   "bash_fails": [
+    34,
+    40
+   ]
+  },
+  "alias": {
+   "summary": {
+    "cases": 48,
+    "bashkit_pass": 48,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 48,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 48,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "append": {
+   "summary": {
+    "cases": 20,
+    "bashkit_pass": 20,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 20,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 20,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "arg-parse": {
+   "summary": {
+    "cases": 3,
+    "bashkit_pass": 3,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 3,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 3,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "arith": {
+   "summary": {
+    "cases": 74,
+    "bashkit_pass": 74,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 74,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 74,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "arith-context": {
+   "summary": {
+    "cases": 16,
+    "bashkit_pass": 16,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 16,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 16,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "arith-dynamic": {
+   "summary": {
+    "cases": 4,
+    "bashkit_pass": 4,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 4,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 4,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "array": {
+   "summary": {
+    "cases": 78,
+    "bashkit_pass": 78,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 78,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 78,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "array-basic": {
+   "summary": {
+    "cases": 5,
+    "bashkit_pass": 5,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 5,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 5,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "array-compat": {
+   "summary": {
+    "cases": 12,
+    "bashkit_pass": 12,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 12,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 12,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "array-literal": {
+   "summary": {
+    "cases": 19,
+    "bashkit_pass": 19,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 19,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 19,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "array-sparse": {
+   "summary": {
+    "cases": 40,
+    "bashkit_pass": 40,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 40,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 40,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "assign-deferred": {
+   "summary": {
+    "cases": 9,
+    "bashkit_pass": 9,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 9,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 9,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "assign-dialects": {
+   "summary": {
+    "cases": 4,
+    "bashkit_pass": 4,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 4,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 4,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "ble-features": {
+   "summary": {
+    "cases": 9,
+    "bashkit_pass": 9,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 9,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 9,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "blog1": {
+   "summary": {
+    "cases": 9,
+    "bashkit_pass": 9,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 9,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 9,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "blog2": {
+   "summary": {
+    "cases": 8,
+    "bashkit_pass": 8,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 8,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 8,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "bool-parse": {
+   "summary": {
+    "cases": 8,
+    "bashkit_pass": 8,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 8,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 8,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "builtin-bash": {
+   "summary": {
+    "cases": 13,
+    "bashkit_pass": 13,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 13,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 13,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "builtin-bind": {
+   "summary": {
+    "cases": 9,
+    "bashkit_pass": 9,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 9,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 9,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "builtin-completion": {
+   "summary": {
+    "cases": 51,
+    "bashkit_pass": 51,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 51,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 51,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "builtin-dirs": {
+   "summary": {
+    "cases": 18,
+    "bashkit_pass": 18,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 18,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 18,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "builtin-echo": {
+   "summary": {
+    "cases": 27,
+    "bashkit_pass": 27,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 27,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 27,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "builtin-eval-source": {
+   "summary": {
+    "cases": 23,
+    "bashkit_pass": 21,
+    "bashkit_pass_pct": 91.3,
+    "bash_pass": 21,
+    "bash_pass_pct": 91.3,
+    "bashkit_pass_of_bash": 21,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": [
+    13,
+    14
+   ]
+  },
+  "builtin-fc": {
+   "summary": {
+    "cases": 14,
+    "bashkit_pass": 14,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 14,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 14,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "builtin-getopts": {
+   "summary": {
+    "cases": 31,
+    "bashkit_pass": 31,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 31,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 31,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "builtin-history": {
+   "summary": {
+    "cases": 17,
+    "bashkit_pass": 17,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 17,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 17,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "builtin-kill": {
+   "summary": {
+    "cases": 20,
+    "bashkit_pass": 20,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 19,
+    "bash_pass_pct": 95.0,
+    "bashkit_pass_of_bash": 19,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": [
+    16
+   ]
+  },
+  "builtin-meta-assign": {
+   "summary": {
+    "cases": 11,
+    "bashkit_pass": 11,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 11,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 11,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "builtin-misc": {
+   "summary": {
+    "cases": 7,
+    "bashkit_pass": 7,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 7,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 7,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "builtin-set": {
+   "summary": {
+    "cases": 24,
+    "bashkit_pass": 24,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 24,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 24,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "builtin-special": {
+   "summary": {
+    "cases": 12,
+    "bashkit_pass": 12,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 12,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 12,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "builtin-times": {
+   "summary": {
+    "cases": 1,
+    "bashkit_pass": 1,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 1,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 1,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "builtin-type-bash": {
+   "summary": {
+    "cases": 31,
+    "bashkit_pass": 31,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 31,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 31,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "builtin-vars": {
+   "summary": {
+    "cases": 41,
+    "bashkit_pass": 39,
+    "bashkit_pass_pct": 95.1,
+    "bash_pass": 39,
+    "bash_pass_pct": 95.1,
+    "bashkit_pass_of_bash": 39,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": [
+    26,
+    32
+   ]
+  },
+  "case_": {
+   "summary": {
+    "cases": 13,
+    "bashkit_pass": 13,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 13,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 13,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "command-parsing": {
+   "summary": {
+    "cases": 5,
+    "bashkit_pass": 5,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 5,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 5,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "command-sub": {
+   "summary": {
+    "cases": 30,
+    "bashkit_pass": 28,
+    "bashkit_pass_pct": 93.3,
+    "bash_pass": 28,
+    "bash_pass_pct": 93.3,
+    "bashkit_pass_of_bash": 28,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": [
+    11,
+    12
+   ]
+  },
+  "command_": {
+   "summary": {
+    "cases": 16,
+    "bashkit_pass": 16,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 16,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 16,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "comments": {
+   "summary": {
+    "cases": 2,
+    "bashkit_pass": 2,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 2,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 2,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "dbracket": {
+   "summary": {
+    "cases": 49,
+    "bashkit_pass": 49,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 49,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 49,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "dparen": {
+   "summary": {
+    "cases": 15,
+    "bashkit_pass": 14,
+    "bashkit_pass_pct": 93.3,
+    "bash_pass": 14,
+    "bash_pass_pct": 93.3,
+    "bashkit_pass_of_bash": 14,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": [
+    10
+   ]
+  },
+  "empty-bodies": {
+   "summary": {
+    "cases": 3,
+    "bashkit_pass": 3,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 3,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 3,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "errexit": {
+   "summary": {
+    "cases": 35,
+    "bashkit_pass": 35,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 35,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 35,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "errexit-osh": {
+   "summary": {
+    "cases": 35,
+    "bashkit_pass": 35,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 35,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 35,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "exit-status": {
+   "summary": {
+    "cases": 11,
+    "bashkit_pass": 11,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 11,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 11,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "explore-parsing": {
+   "summary": {
+    "cases": 5,
+    "bashkit_pass": 5,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 5,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 5,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "extglob-files": {
+   "summary": {
+    "cases": 23,
+    "bashkit_pass": 23,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 23,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 23,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "extglob-match": {
+   "summary": {
+    "cases": 29,
+    "bashkit_pass": 29,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 29,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 29,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "for-expr": {
+   "summary": {
+    "cases": 9,
+    "bashkit_pass": 8,
+    "bashkit_pass_pct": 88.9,
+    "bash_pass": 8,
+    "bash_pass_pct": 88.9,
+    "bashkit_pass_of_bash": 8,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": [
+    6
+   ]
+  },
+  "func-parsing": {
+   "summary": {
+    "cases": 15,
+    "bashkit_pass": 15,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 15,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 15,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "glob-bash": {
+   "summary": {
+    "cases": 8,
+    "bashkit_pass": 8,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 8,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 8,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "globignore": {
+   "summary": {
+    "cases": 18,
+    "bashkit_pass": 18,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 18,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 18,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "globstar": {
+   "summary": {
+    "cases": 5,
+    "bashkit_pass": 5,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 5,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 5,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "here-doc": {
+   "summary": {
+    "cases": 36,
+    "bashkit_pass": 36,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 36,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 36,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "if_": {
+   "summary": {
+    "cases": 5,
+    "bashkit_pass": 5,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 5,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 5,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "interactive": {
+   "summary": {
+    "cases": 18,
+    "bashkit_pass": 18,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 18,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 18,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "introspect": {
+   "summary": {
+    "cases": 13,
+    "bashkit_pass": 12,
+    "bashkit_pass_pct": 92.3,
+    "bash_pass": 12,
+    "bash_pass_pct": 92.3,
+    "bashkit_pass_of_bash": 12,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": [
+    8
+   ]
+  },
+  "known-differences": {
+   "summary": {
+    "cases": 2,
+    "bashkit_pass": 2,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 2,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 2,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "let": {
+   "summary": {
+    "cases": 2,
+    "bashkit_pass": 2,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 2,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 2,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "loop": {
+   "summary": {
+    "cases": 29,
+    "bashkit_pass": 29,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 29,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 29,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "nix-idioms": {
+   "summary": {
+    "cases": 6,
+    "bashkit_pass": 6,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 6,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 6,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "nocasematch-match": {
+   "summary": {
+    "cases": 6,
+    "bashkit_pass": 6,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 6,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 6,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "nul-bytes": {
+   "summary": {
+    "cases": 16,
+    "bashkit_pass": 16,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 16,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 16,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "paren-ambiguity": {
+   "summary": {
+    "cases": 9,
+    "bashkit_pass": 9,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 9,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 9,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "posix": {
+   "summary": {
+    "cases": 15,
+    "bashkit_pass": 15,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 15,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 15,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "print-source-code": {
+   "summary": {
+    "cases": 4,
+    "bashkit_pass": 4,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 4,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 4,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "prompt": {
+   "summary": {
+    "cases": 33,
+    "bashkit_pass": 32,
+    "bashkit_pass_pct": 97.0,
+    "bash_pass": 29,
+    "bash_pass_pct": 87.9,
+    "bashkit_pass_of_bash": 29,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": [
+    0,
+    1,
+    3,
+    32
+   ]
+  },
+  "redirect-command": {
+   "summary": {
+    "cases": 23,
+    "bashkit_pass": 23,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 23,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 23,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "redirect-multi": {
+   "summary": {
+    "cases": 13,
+    "bashkit_pass": 13,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 13,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 13,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "regex": {
+   "summary": {
+    "cases": 37,
+    "bashkit_pass": 37,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 37,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 37,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "sh-func": {
+   "summary": {
+    "cases": 12,
+    "bashkit_pass": 12,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 12,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 12,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "sh-options-bash": {
+   "summary": {
+    "cases": 9,
+    "bashkit_pass": 9,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 9,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 9,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "smoke": {
+   "summary": {
+    "cases": 18,
+    "bashkit_pass": 18,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 18,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 18,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "strict-options": {
+   "summary": {
+    "cases": 17,
+    "bashkit_pass": 15,
+    "bashkit_pass_pct": 88.2,
+    "bash_pass": 15,
+    "bash_pass_pct": 88.2,
+    "bashkit_pass_of_bash": 15,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": [
+    3,
+    5
+   ]
+  },
+  "subshell": {
+   "summary": {
+    "cases": 2,
+    "bashkit_pass": 2,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 2,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 2,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "temp-binding": {
+   "summary": {
+    "cases": 4,
+    "bashkit_pass": 4,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 4,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 4,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "tilde": {
+   "summary": {
+    "cases": 14,
+    "bashkit_pass": 14,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 14,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 14,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "toysh-posix": {
+   "summary": {
+    "cases": 23,
+    "bashkit_pass": 23,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 23,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 23,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "type-compat": {
+   "summary": {
+    "cases": 7,
+    "bashkit_pass": 5,
+    "bashkit_pass_pct": 71.4,
+    "bash_pass": 5,
+    "bash_pass_pct": 71.4,
+    "bashkit_pass_of_bash": 5,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": [
+    3,
+    5
+   ]
+  },
+  "var-num": {
+   "summary": {
+    "cases": 7,
+    "bashkit_pass": 7,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 7,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 7,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "var-op-bash": {
+   "summary": {
+    "cases": 27,
+    "bashkit_pass": 26,
+    "bashkit_pass_pct": 96.3,
+    "bash_pass": 26,
+    "bash_pass_pct": 96.3,
+    "bashkit_pass_of_bash": 26,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": [
+    3
+   ]
+  },
+  "var-op-slice": {
+   "summary": {
+    "cases": 22,
+    "bashkit_pass": 22,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 22,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 22,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "var-op-strip": {
+   "summary": {
+    "cases": 29,
+    "bashkit_pass": 29,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 29,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 29,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "var-op-test": {
+   "summary": {
+    "cases": 37,
+    "bashkit_pass": 37,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 37,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 37,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "var-sub": {
+   "summary": {
+    "cases": 6,
+    "bashkit_pass": 6,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 6,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 6,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "whitespace": {
+   "summary": {
+    "cases": 5,
+    "bashkit_pass": 0,
+    "bashkit_pass_pct": 0.0,
+    "bash_pass": 0,
+    "bash_pass_pct": 0.0,
+    "bashkit_pass_of_bash": 0,
+    "pass_rate": 0.0
+   },
+   "missed": [],
+   "bash_fails": [
+    0,
+    1,
+    2,
+    3,
+    4
+   ]
+  },
+  "word-eval": {
+   "summary": {
+    "cases": 8,
+    "bashkit_pass": 8,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 8,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 8,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "word-split": {
+   "summary": {
+    "cases": 55,
+    "bashkit_pass": 53,
+    "bashkit_pass_pct": 96.4,
+    "bash_pass": 53,
+    "bash_pass_pct": 96.4,
+    "bashkit_pass_of_bash": 53,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": [
+    24,
+    25
+   ]
+  },
+  "xtrace": {
+   "summary": {
+    "cases": 19,
+    "bashkit_pass": 19,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 19,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 19,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  },
+  "ysh-builtin-private": {
+   "summary": {
+    "cases": 23,
+    "bashkit_pass": 22,
+    "bashkit_pass_pct": 95.7,
+    "bash_pass": 22,
+    "bash_pass_pct": 95.7,
+    "bashkit_pass_of_bash": 22,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": [
+    18
+   ]
+  },
+  "zsh-idioms": {
+   "summary": {
+    "cases": 3,
+    "bashkit_pass": 3,
+    "bashkit_pass_pct": 100.0,
+    "bash_pass": 3,
+    "bash_pass_pct": 100.0,
+    "bashkit_pass_of_bash": 3,
+    "pass_rate": 100.0
+   },
+   "missed": [],
+   "bash_fails": []
+  }
+ }
+}
diff --git a/scripts/oils-spec/results/oils-spec-linux-x86_64-20261009T010244Z.md b/scripts/oils-spec/results/oils-spec-linux-x86_64-20261009T010244Z.md
new file mode 100644
index 000000000..3ff9150e0
--- /dev/null
+++ b/scripts/oils-spec/results/oils-spec-linux-x86_64-20261009T010244Z.md
@@ -0,0 +1,167 @@
+# Oils spec pass rate
+
+- Oils revision: [`57d3f0d088c3`](https://github.com/oils-for-unix/oils/tree/57d3f0d088c36340bc4b3038208e58ea02acf15c)
+- bashkit commit: `298bf8f9cfd1`
+- bash: 5.2.21(1)-release
+- Spec files: 132 (bash column; 91 without one skipped)
+- Runtime: 21.4 s, 4 jobs, 10 s per-case timeout
+
+## Headline
+
+**97.3%** — bashkit passes 2618 of the 2692 cases real bash passes.
+
+| Shell | Pass | Cases | % |
+|-------|-----:|------:|--:|
+| bash | 2692 | 2759 | 97.6 |
+| bashkit | 2628 | 2759 | 95.3 |
+
+## bashkit failures by class
+
+Heuristic keyword classes; every case still counts in the rate.
+
+| Class | Failing cases |
+|-------|--------------:|
+| behavior | 48 |
+| processes | 10 |
+| host | 7 |
+| signals | 5 |
+| interactive | 4 |
+
+## Per spec file
+
+Sorted by cases bashkit misses among those bash passes.
+
+| Spec file | Cases | bash | bashkit | Missed | Rate % |
+|-----------|------:|-----:|--------:|-------:|-------:|
+| background | 27 | 27 | 20 | 7 | 74.1 |
+| bugs | 29 | 29 | 24 | 5 | 82.8 |
+| builtin-trap | 33 | 33 | 29 | 4 | 87.9 |
+| brace-expansion | 55 | 55 | 52 | 3 | 94.5 |
+| builtin-meta | 18 | 18 | 15 | 3 | 83.3 |
+| builtin-trap-bash | 23 | 23 | 20 | 3 | 87.0 |
+| sh-options | 39 | 39 | 36 | 3 | 92.3 |
+| assign-extended | 39 | 35 | 33 | 2 | 94.3 |
+| builtin-read | 64 | 64 | 62 | 2 | 96.9 |
+| builtin-trap-err | 23 | 22 | 20 | 2 | 90.9 |
+| builtin-umask | 24 | 24 | 22 | 2 | 91.7 |
+| fatal-errors | 5 | 5 | 3 | 2 | 60.0 |
+| nameref | 32 | 32 | 30 | 2 | 93.8 |
+| redirect | 41 | 41 | 39 | 2 | 95.1 |
+| serialize | 10 | 10 | 8 | 2 | 80.0 |
+| sh-usage | 24 | 24 | 22 | 2 | 91.7 |
+| var-op-len | 9 | 8 | 7 | 2 | 75.0 |
+| var-op-patsub | 28 | 28 | 26 | 2 | 92.9 |
+| var-ref | 31 | 30 | 28 | 2 | 93.3 |
+| array-assign | 11 | 11 | 10 | 1 | 90.9 |
+| array-assoc | 42 | 36 | 35 | 1 | 97.2 |
+| assign | 48 | 45 | 44 | 1 | 97.8 |
+| ble-idioms | 26 | 26 | 25 | 1 | 96.2 |
+| ble-unset | 5 | 5 | 4 | 1 | 80.0 |
+| builtin-bracket | 52 | 50 | 49 | 1 | 98.0 |
+| builtin-cd | 30 | 28 | 27 | 1 | 96.4 |
+| builtin-printf | 63 | 58 | 60 | 1 | 98.3 |
+| builtin-process | 26 | 24 | 24 | 1 | 95.8 |
+| builtin-type | 6 | 6 | 5 | 1 | 83.3 |
+| divergence | 4 | 4 | 3 | 1 | 75.0 |
+| glob | 39 | 37 | 36 | 1 | 97.3 |
+| history-expand | 1 | 1 | 0 | 1 | 0.0 |
+| parse-errors | 27 | 25 | 24 | 1 | 96.0 |
+| pipeline | 26 | 25 | 24 | 1 | 96.0 |
+| process-sub | 9 | 8 | 8 | 1 | 87.5 |
+| quote | 35 | 35 | 34 | 1 | 97.1 |
+| toysh | 8 | 8 | 7 | 1 | 87.5 |
+| unicode | 7 | 2 | 1 | 1 | 50.0 |
+| var-sub-quote | 41 | 41 | 40 | 1 | 97.6 |
+| vars-bash | 1 | 1 | 0 | 1 | 0.0 |
+| vars-special | 42 | 40 | 39 | 1 | 97.5 |
+| alias | 48 | 48 | 48 | 0 | 100.0 |
+| append | 20 | 20 | 20 | 0 | 100.0 |
+| arg-parse | 3 | 3 | 3 | 0 | 100.0 |
+| arith | 74 | 74 | 74 | 0 | 100.0 |
+| arith-context | 16 | 16 | 16 | 0 | 100.0 |
+| arith-dynamic | 4 | 4 | 4 | 0 | 100.0 |
+| array | 78 | 78 | 78 | 0 | 100.0 |
+| array-basic | 5 | 5 | 5 | 0 | 100.0 |
+| array-compat | 12 | 12 | 12 | 0 | 100.0 |
+| array-literal | 19 | 19 | 19 | 0 | 100.0 |
+| array-sparse | 40 | 40 | 40 | 0 | 100.0 |
+| assign-deferred | 9 | 9 | 9 | 0 | 100.0 |
+| assign-dialects | 4 | 4 | 4 | 0 | 100.0 |
+| ble-features | 9 | 9 | 9 | 0 | 100.0 |
+| blog1 | 9 | 9 | 9 | 0 | 100.0 |
+| blog2 | 8 | 8 | 8 | 0 | 100.0 |
+| bool-parse | 8 | 8 | 8 | 0 | 100.0 |
+| builtin-bash | 13 | 13 | 13 | 0 | 100.0 |
+| builtin-bind | 9 | 9 | 9 | 0 | 100.0 |
+| builtin-completion | 51 | 51 | 51 | 0 | 100.0 |
+| builtin-dirs | 18 | 18 | 18 | 0 | 100.0 |
+| builtin-echo | 27 | 27 | 27 | 0 | 100.0 |
+| builtin-eval-source | 23 | 21 | 21 | 0 | 100.0 |
+| builtin-fc | 14 | 14 | 14 | 0 | 100.0 |
+| builtin-getopts | 31 | 31 | 31 | 0 | 100.0 |
+| builtin-history | 17 | 17 | 17 | 0 | 100.0 |
+| builtin-kill | 20 | 19 | 20 | 0 | 100.0 |
+| builtin-meta-assign | 11 | 11 | 11 | 0 | 100.0 |
+| builtin-misc | 7 | 7 | 7 | 0 | 100.0 |
+| builtin-set | 24 | 24 | 24 | 0 | 100.0 |
+| builtin-special | 12 | 12 | 12 | 0 | 100.0 |
+| builtin-times | 1 | 1 | 1 | 0 | 100.0 |
+| builtin-type-bash | 31 | 31 | 31 | 0 | 100.0 |
+| builtin-vars | 41 | 39 | 39 | 0 | 100.0 |
+| case_ | 13 | 13 | 13 | 0 | 100.0 |
+| command-parsing | 5 | 5 | 5 | 0 | 100.0 |
+| command-sub | 30 | 28 | 28 | 0 | 100.0 |
+| command_ | 16 | 16 | 16 | 0 | 100.0 |
+| comments | 2 | 2 | 2 | 0 | 100.0 |
+| dbracket | 49 | 49 | 49 | 0 | 100.0 |
+| dparen | 15 | 14 | 14 | 0 | 100.0 |
+| empty-bodies | 3 | 3 | 3 | 0 | 100.0 |
+| errexit | 35 | 35 | 35 | 0 | 100.0 |
+| errexit-osh | 35 | 35 | 35 | 0 | 100.0 |
+| exit-status | 11 | 11 | 11 | 0 | 100.0 |
+| explore-parsing | 5 | 5 | 5 | 0 | 100.0 |
+| extglob-files | 23 | 23 | 23 | 0 | 100.0 |
+| extglob-match | 29 | 29 | 29 | 0 | 100.0 |
+| for-expr | 9 | 8 | 8 | 0 | 100.0 |
+| func-parsing | 15 | 15 | 15 | 0 | 100.0 |
+| glob-bash | 8 | 8 | 8 | 0 | 100.0 |
+| globignore | 18 | 18 | 18 | 0 | 100.0 |
+| globstar | 5 | 5 | 5 | 0 | 100.0 |
+| here-doc | 36 | 36 | 36 | 0 | 100.0 |
+| if_ | 5 | 5 | 5 | 0 | 100.0 |
+| interactive | 18 | 18 | 18 | 0 | 100.0 |
+| introspect | 13 | 12 | 12 | 0 | 100.0 |
+| known-differences | 2 | 2 | 2 | 0 | 100.0 |
+| let | 2 | 2 | 2 | 0 | 100.0 |
+| loop | 29 | 29 | 29 | 0 | 100.0 |
+| nix-idioms | 6 | 6 | 6 | 0 | 100.0 |
+| nocasematch-match | 6 | 6 | 6 | 0 | 100.0 |
+| nul-bytes | 16 | 16 | 16 | 0 | 100.0 |
+| paren-ambiguity | 9 | 9 | 9 | 0 | 100.0 |
+| posix | 15 | 15 | 15 | 0 | 100.0 |
+| print-source-code | 4 | 4 | 4 | 0 | 100.0 |
+| prompt | 33 | 29 | 32 | 0 | 100.0 |
+| redirect-command | 23 | 23 | 23 | 0 | 100.0 |
+| redirect-multi | 13 | 13 | 13 | 0 | 100.0 |
+| regex | 37 | 37 | 37 | 0 | 100.0 |
+| sh-func | 12 | 12 | 12 | 0 | 100.0 |
+| sh-options-bash | 9 | 9 | 9 | 0 | 100.0 |
+| smoke | 18 | 18 | 18 | 0 | 100.0 |
+| strict-options | 17 | 15 | 15 | 0 | 100.0 |
+| subshell | 2 | 2 | 2 | 0 | 100.0 |
+| temp-binding | 4 | 4 | 4 | 0 | 100.0 |
+| tilde | 14 | 14 | 14 | 0 | 100.0 |
+| toysh-posix | 23 | 23 | 23 | 0 | 100.0 |
+| type-compat | 7 | 5 | 5 | 0 | 100.0 |
+| var-num | 7 | 7 | 7 | 0 | 100.0 |
+| var-op-bash | 27 | 26 | 26 | 0 | 100.0 |
+| var-op-slice | 22 | 22 | 22 | 0 | 100.0 |
+| var-op-strip | 29 | 29 | 29 | 0 | 100.0 |
+| var-op-test | 37 | 37 | 37 | 0 | 100.0 |
+| var-sub | 6 | 6 | 6 | 0 | 100.0 |
+| whitespace | 5 | 0 | 0 | 0 | 0.0 |
+| word-eval | 8 | 8 | 8 | 0 | 100.0 |
+| word-split | 55 | 53 | 53 | 0 | 100.0 |
+| xtrace | 19 | 19 | 19 | 0 | 100.0 |
+| ysh-builtin-private | 23 | 22 | 22 | 0 | 100.0 |
+| zsh-idioms | 3 | 3 | 3 | 0 | 100.0 |