diff --git a/crates/bashkit-cli/src/interactive.rs b/crates/bashkit-cli/src/interactive.rs
index d3a318df9..f7d343864 100644
--- a/crates/bashkit-cli/src/interactive.rs
+++ b/crates/bashkit-cli/src/interactive.rs
@@ -34,6 +34,7 @@ fn is_incomplete_input(err_msg: &str) -> bool {
     lower.contains("unterminated")
         || lower.contains("unexpected end of input")
         || lower.contains("unexpected eof")
+        || lower.contains("unexpected end of file")
         || lower.contains("syntax error: empty")
         || lower.contains("expected 'fi'")
         || lower.contains("expected 'done'")
@@ -627,6 +628,14 @@ mod tests {
         assert!(is_incomplete_input("syntax error: empty brace group"));
     }
 
+    #[test]
+    fn incomplete_unexpected_end_of_file() {
+        // The parser's bash wording for input that ran out mid-construct.
+        assert!(is_incomplete_input(
+            "parse error at line 2, column 1: syntax error: unexpected end of file"
+        ));
+    }
+
     #[test]
     fn incomplete_missing_closing_keyword() {
         assert!(is_incomplete_input("expected 'fi'"));
diff --git a/crates/bashkit-cli/src/main.rs b/crates/bashkit-cli/src/main.rs
index f0c88496a..c972f953b 100644
--- a/crates/bashkit-cli/src/main.rs
+++ b/crates/bashkit-cli/src/main.rs
@@ -495,7 +495,16 @@ fn run_oneshot(args: Args, mode: CliMode) -> Result<i32> {
                 // reported on stderr and exits 2 (the partial-run case already
                 // returns exit 2 from the library).
                 Err(e @ bashkit::Error::Parse { .. }) => {
-                    eprintln!("bash: syntax error: {e}");
+                    // Named like bash: `bash: -c: line 1: ...` or `script.sh: line 1: ...`.
+                    let arg0 = args.script.as_ref().map(|p| p.display().to_string());
+                    let who = match (&args.command, arg0) {
+                        (None, Some(path)) => path,
+                        (_, arg0) => format!("{}: -c", arg0.as_deref().unwrap_or("bash")),
+                    };
+                    let report = e
+                        .syntax_report(&who, &script)
+                        .unwrap_or_else(|| format!("bash: syntax error: {e}\n"));
+                    eprint!("{report}");
                     return Ok(2);
                 }
                 Err(e) => return Err(anyhow::Error::new(e).context(context)),
diff --git a/crates/bashkit-cli/tests/cli_oneshot.rs b/crates/bashkit-cli/tests/cli_oneshot.rs
index d3924f4b4..3e066656c 100644
--- a/crates/bashkit-cli/tests/cli_oneshot.rs
+++ b/crates/bashkit-cli/tests/cli_oneshot.rs
@@ -214,31 +214,36 @@ fn parse_error_reports_on_stderr_and_exits_nonzero() {
     let out = run(&["-c", "if ["]);
     // bash exits 2 on a syntax error.
     assert_eq!(code(&out), 2);
-    let err = stderr(&out);
-    assert!(
-        err.starts_with("bash: syntax error: parse error"),
-        "stderr: {err}"
+    // Worded and numbered like bash: input ran out, so the line after the last.
+    assert_eq!(
+        stderr(&out),
+        "bash: -c: line 2: syntax error: unexpected end of file\n"
     );
-    assert!(err.ends_with('\n'), "stderr: {err:?}");
     assert_eq!(stdout(&out), "", "parse errors must not write to stdout");
 }
 
 #[test]
 fn script_parse_error_exits_2_with_or_without_earlier_commands() {
     let dir = tempfile::tempdir().unwrap();
-    for (body, want_stdout) in [
-        ("[[ abc =~ ( ]]\n", ""),
-        ("echo ok\n[[ abc =~ ( ]]\n", "ok\n"),
+    for (body, want_stdout, line) in [
+        ("[[ abc =~ ( ]]\n", "", 1),
+        ("echo ok\n[[ abc =~ ( ]]\n", "ok\n", 2),
     ] {
         let script = dir.path().join("bad.sh");
         std::fs::write(&script, body).unwrap();
-        let out = run(&[script.to_str().unwrap()]);
+        let path = script.to_str().unwrap();
+        let out = run(&[path]);
         assert_eq!(code(&out), 2, "{body:?}");
         assert_eq!(stdout(&out), want_stdout, "{body:?}");
-        assert!(
-            stderr(&out).starts_with("bash: syntax error: "),
-            "{body:?}: {}",
-            stderr(&out)
+        // bash's two diagnostics, named by the script path.
+        assert_eq!(
+            stderr(&out),
+            format!(
+                "{path}: line {line}: unexpected EOF while looking for matching `)'\n\
+                 {path}: line {}: unexpected argument to conditional binary operator\n",
+                line + 1
+            ),
+            "{body:?}"
         );
     }
 }
diff --git a/crates/bashkit/src/error.rs b/crates/bashkit/src/error.rs
index 7d498ad88..b37a8e2b6 100644
--- a/crates/bashkit/src/error.rs
+++ b/crates/bashkit/src/error.rs
@@ -138,6 +138,28 @@ impl Error {
         }
     }
 
+    /// bash's report of this syntax error in `source`, as read by `who`
+    /// (`bash: -c`, a script path): `who: line N: message`, followed by the
+    /// offending source line for a `near unexpected token` error. `None` for
+    /// errors other than [`Error::Parse`].
+    ///
+    /// ```
+    /// let err = bashkit::parser::Parser::new("if then fi").parse().unwrap_err();
+    /// assert_eq!(
+    ///     err.syntax_report("bash: -c", "if then fi").unwrap(),
+    ///     "bash: -c: line 1: syntax error near unexpected token `then'\n\
+    ///      bash: -c: line 1: `if then fi'\n"
+    /// );
+    /// ```
+    pub fn syntax_report(&self, who: &str, source: &str) -> Option<String> {
+        match self {
+            Self::Parse { message, line, .. } => {
+                Some(syntax_report(who, source, message, *line, 0))
+            }
+            _ => None,
+        }
+    }
+
     /// THREAT[TM-INF-016]: Create an I/O error with sanitized message.
     /// Strips host-internal paths from the error message to prevent information
     /// leakage to the sandbox guest.
@@ -251,6 +273,47 @@ fn sanitize_error_message(msg: &str) -> String {
     result
 }
 
+/// See [`Error::syntax_report`]. `shift` moves the reported line number
+/// (eval'd text counts from the eval's own line). A message line after the
+/// first that reads `line N: text` is a further diagnostic bash prints for
+/// the same error, on its own line number.
+pub(crate) fn syntax_report(
+    who: &str,
+    source: &str,
+    message: &str,
+    line: usize,
+    shift: usize,
+) -> String {
+    let message = if message.starts_with("syntax error") || message.starts_with("unexpected EOF") {
+        message.to_string()
+    } else {
+        format!("syntax error: {message}")
+    };
+    if line == 0 {
+        return format!("{who}: {message}\n");
+    }
+    let at = line + shift;
+    let mut lines = message.lines();
+    let first = lines.next().unwrap_or_default();
+    let mut out = format!("{who}: line {at}: {first}\n");
+    if first.contains("near unexpected token")
+        && let Some(text) = source.lines().nth(line - 1)
+    {
+        out.push_str(&format!("{who}: line {at}: `{text}'\n"));
+    }
+    for more in lines {
+        let further = more.strip_prefix("line ").and_then(|rest| {
+            let (n, text) = rest.split_once(": ")?;
+            Some((n.parse::<usize>().ok()? + shift, text))
+        });
+        match further {
+            Some((n, text)) => out.push_str(&format!("{who}: line {n}: {text}\n")),
+            None => out.push_str(&format!("{who}: line {at}: {more}\n")),
+        }
+    }
+    out
+}
+
 #[cfg(test)]
 mod tests {
     /// A VFS message that only restates its errno is swapped for the
diff --git a/crates/bashkit/src/interpreter/mod.rs b/crates/bashkit/src/interpreter/mod.rs
index bddfb7065..e0f7816ab 100644
--- a/crates/bashkit/src/interpreter/mod.rs
+++ b/crates/bashkit/src/interpreter/mod.rs
@@ -35,12 +35,14 @@ pub(crate) mod pipe;
 mod redirection;
 mod state;
 mod time_command;
+mod xtrace;
 
 #[allow(unused_imports)]
 pub use jobs::{JobInfo, JobState, JobTable, SharedJobTable};
 pub use state::{BuiltinSideEffect, ControlFlow, ExecResult};
 use time_command::{
-    TimeUsage, render_time_format, sanitize_time_path, validate_time_format, verbose_time_report,
+    TimeUsage, render_time_format, render_timeformat, sanitize_time_path, validate_time_format,
+    verbose_time_report,
 };
 // Re-export snapshot type for public API
 
@@ -845,18 +847,25 @@ fn decode_file_bytes_for_path(_path: &Path, bytes: &[u8]) -> String {
 fn nested_partial_parse(
     (mut script, error): (Script, Option<crate::error::Error>),
     noexec: bool,
-    shell_name: &str,
+    who: &str,
+    source: &str,
 ) -> Result<Script> {
     match error {
         None => Ok(script),
         Some(e) if noexec || script.commands.is_empty() => Err(e),
         Some(e) => {
-            script.trailing_error = Some(format!("{shell_name}: syntax error: {e}\n"));
+            script.trailing_error = Some(nested_syntax_report(&e, who, source));
             Ok(script)
         }
     }
 }
 
+/// A child shell's syntax error as bash reports it (`bash: -c: line 1: ...`).
+fn nested_syntax_report(e: &crate::error::Error, who: &str, source: &str) -> String {
+    e.syntax_report(who, source)
+        .unwrap_or_else(|| format!("{who}: syntax error: {e}\n"))
+}
+
 /// Check if a path refers to /dev/null after normalization.
 /// Handles attempts to bypass via paths like `/dev/../dev/null`.
 fn is_dev_null(path: &Path) -> bool {
@@ -1340,6 +1349,7 @@ struct SubshellSnapshot {
     last_bg_pid: Option<String>,
     seconds_base: (crate::time_compat::Instant, i64),
     bash_subshell: u32,
+    xtrace_depth: usize,
     err_trap_dormant: bool,
     line_base: usize,
 }
@@ -1460,6 +1470,9 @@ pub struct Interpreter {
     builtin_stdin_pipe: Option<Arc<pipe::Pipe>>,
     /// `$BASH_SUBSHELL`: subshell nesting (`( )`, `$( )`, pipeline stages, jobs).
     bash_subshell: u32,
+    /// Extra `set -x` prefix levels: `$(...)`, `eval`, `source` and trap
+    /// handlers each repeat PS4's first character once more (`++ cmd`).
+    xtrace_depth: usize,
     /// Position within the current argument while `getopts` walks a clustered
     /// short-option group (e.g. `-abc`). Interpreter-internal working state for
     /// `execute_getopts`; `0` means "at the start of the next option group".
@@ -2071,6 +2084,7 @@ impl Interpreter {
             builtin_stdout_pipe: None,
             builtin_stdin_pipe: None,
             bash_subshell: 0,
+            xtrace_depth: 0,
             getopts_char_idx: 0,
             last_bg_pid: None,
             output_callback: None,
@@ -2252,6 +2266,7 @@ impl Interpreter {
             builtin_stdout_pipe: None,
             builtin_stdin_pipe: None,
             bash_subshell: self.bash_subshell + 1,
+            xtrace_depth: self.xtrace_depth,
             getopts_char_idx: self.getopts_char_idx,
             last_bg_pid: self.last_bg_pid.clone(),
             output_callback: None,
@@ -2549,6 +2564,7 @@ impl Interpreter {
         self.err_trap_dormant = false;
         self.err_trap_skip_stage = false;
         self.line_base = 0;
+        self.xtrace_depth = 0;
         // An exec that failed mid-command must not hand its queued `$(...)`
         // stderr to the next exec.
         self.subst_stderr = crate::StreamData::new();
@@ -3666,6 +3682,21 @@ impl Interpreter {
         }
     }
 
+    /// `$LINENO` for a command about to run. `(( ))` and `[[ ]]` carry no
+    /// position of their own: they keep the line of the list around them
+    /// (`[[ $LINENO -gt 1 ]] && ...`), not line 1.
+    fn set_command_lineno(&mut self, command: &Command) {
+        if !matches!(
+            command,
+            Command::Compound(
+                CompoundCommand::Arithmetic(_) | CompoundCommand::Conditional(_),
+                _
+            )
+        ) {
+            self.current_line = self.line_base + Self::command_line(command);
+        }
+    }
+
     fn execute_command<'a>(
         &'a mut self,
         command: &'a Command,
@@ -3679,7 +3710,7 @@ impl Interpreter {
             let emit_before = self.output_emit_count;
             self.check_cancelled()?;
             // Update current line for $LINENO
-            self.current_line = self.line_base + Self::command_line(command);
+            self.set_command_lineno(command);
             if let Some(name) = Self::command_name(command) {
                 self.last_command_name = name.to_string();
             }
@@ -3813,7 +3844,7 @@ impl Interpreter {
                 && !self.is_in_condition_sequence()
             {
                 // `$LINENO` in the handler is the failing command's line.
-                self.current_line = self.line_base + Self::command_line(command);
+                self.set_command_lineno(command);
                 Box::pin(self.run_err_trap_after(r, emit_before)).await;
             }
             result
@@ -4699,13 +4730,6 @@ impl Interpreter {
                 return Ok(false);
             }
 
-            // Handle negation
-            if Self::conditional_word_literal(&words[0]) == Some("!") {
-                let negated = !self.evaluate_conditional_words(&words[1..]).await?;
-                self.cond_regex_error = false;
-                return Ok(negated);
-            }
-
             // Handle parentheses only when they wrap the whole expression.
             if Self::conditional_words_wrapped(words) {
                 return self
@@ -4729,6 +4753,42 @@ impl Interpreter {
                 return self.evaluate_conditional_words(&words[i + 1..]).await;
             }
 
+            // `!` binds tighter than `&&`/`||`: `[[ ! -z x || y ]]` is
+            // `(! -z x) || y`.
+            if Self::conditional_word_literal(&words[0]) == Some("!") {
+                let rest = &words[1..];
+                if self.is_xtrace_enabled() && Self::conditional_words_leaf(rest) {
+                    // Traced as one primary: `+ [[ ! -z x ]]`.
+                    let negated = !self.evaluate_conditional_leaf(rest, true).await?;
+                    self.cond_regex_error = false;
+                    return Ok(negated);
+                }
+                let negated = !self.evaluate_conditional_words(rest).await?;
+                self.cond_regex_error = false;
+                return Ok(negated);
+            }
+
+            self.evaluate_conditional_leaf(words, false).await
+        })
+    }
+
+    /// A `[[ ]]` word list with no `!`, `&&`, `||` or wrapping parens on top.
+    fn conditional_words_leaf(words: &[Word]) -> bool {
+        !words.is_empty()
+            && Self::conditional_word_literal(&words[0]) != Some("!")
+            && !Self::conditional_words_wrapped(words)
+            && Self::find_top_level_conditional_word_operator(words, "||").is_none()
+            && Self::find_top_level_conditional_word_operator(words, "&&").is_none()
+    }
+
+    /// Evaluate one `[[ ]]` primary. `invert` only shapes its `set -x` line;
+    /// the caller negates.
+    fn evaluate_conditional_leaf<'a>(
+        &'a mut self,
+        words: &'a [Word],
+        invert: bool,
+    ) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<bool>> + Send + 'a>> {
+        Box::pin(async move {
             // Leaf: expand words and evaluate as a simple condition. The
             // right side of `==`/`=`/`!=` is a pattern: its quoted parts
             // match literally.
@@ -4746,6 +4806,10 @@ impl Interpreter {
                     self.expand_word(word).await?
                 });
             }
+            if self.is_xtrace_enabled() {
+                let prefix = self.xtrace_prefix().await;
+                self.queue_xtrace_line(&prefix, &xtrace::cond_term(invert, &expanded));
+            }
             self.cond_regex_error = false;
             Ok(self.evaluate_conditional(&expanded).await)
         })
@@ -4761,11 +4825,6 @@ impl Interpreter {
                 return false;
             }
 
-            // Handle negation
-            if args[0] == "!" {
-                return !self.evaluate_conditional(&args[1..]).await;
-            }
-
             // Handle parentheses only when they wrap the whole expression.
             if Self::conditional_args_wrapped(args) {
                 return self.evaluate_conditional(&args[1..args.len() - 1]).await;
@@ -4781,6 +4840,11 @@ impl Interpreter {
                     && self.evaluate_conditional(&args[i + 1..]).await;
             }
 
+            // `!` binds tighter than `&&`/`||`.
+            if args[0] == "!" {
+                return !self.evaluate_conditional(&args[1..]).await;
+            }
+
             match args.len() {
                 1 => !args[0].is_empty(),
                 2 => {
@@ -5237,6 +5301,13 @@ impl Interpreter {
             }
         } else if time_cmd.verbose {
             verbose_time_report(&usage)
+        } else if !time_cmd.posix_format
+            && let Some(timeformat) = self.scoped.variables.get("TIMEFORMAT")
+        {
+            match render_timeformat(timeformat, elapsed) {
+                Ok(report) => report,
+                Err(bad) => self.diag(format!("TIMEFORMAT: `{bad}': invalid format character\n")),
+            }
         } else if time_cmd.posix_format {
             format!(
                 "real {:.2}\nuser unavailable\nsys unavailable\n",
@@ -5656,12 +5727,28 @@ impl Interpreter {
         Ok((command_string, script_file, script_args, noexec, shell_opts))
     }
 
+    /// `bash`/`sh` as a command. Its redirects apply to everything it
+    /// reports, including a syntax error or a missing script file
+    /// (`bash -c 'if then fi' 2>/dev/null` is silent).
     async fn execute_shell(
         &mut self,
         shell_name: &str,
         args: &[String],
         stdin: Option<crate::StreamData>,
         redirects: &[Redirect],
+    ) -> Result<ExecResult> {
+        let result = self
+            .execute_shell_unredirected(shell_name, args, stdin, redirects)
+            .await?;
+        self.apply_redirections(result, redirects).await
+    }
+
+    async fn execute_shell_unredirected(
+        &mut self,
+        shell_name: &str,
+        args: &[String],
+        stdin: Option<crate::StreamData>,
+        redirects: &[Redirect],
     ) -> Result<ExecResult> {
         // Parse arguments — Err means early-return result (--version, --help, errors)
         let (command_string, script_file, script_args, noexec, shell_opts) =
@@ -5703,6 +5790,22 @@ impl Interpreter {
             ));
         }
 
+        // Who reports a syntax error: `bash: -c` (or `$0: -c`), the script
+        // file, or the shell itself for stdin.
+        let who = if is_command_mode {
+            format!(
+                "{}: -c",
+                script_args
+                    .first()
+                    .map(String::as_str)
+                    .unwrap_or(shell_name)
+            )
+        } else if let Some(file) = &script_file {
+            file.clone()
+        } else {
+            shell_name.to_string()
+        };
+
         // THREAT[TM-DOS-021]: Propagate interpreter's parser limits to child shell
         let max_ast_depth = self.limits.max_ast_depth;
         let max_parser_operations = self.limits.max_parser_operations;
@@ -5725,11 +5828,11 @@ impl Interpreter {
                 Some(parser_timeout),
             )
             .with_execution_budget(self.execution_budget.clone());
-            match nested_partial_parse(parser.parse_recovering(), noexec, shell_name) {
+            match nested_partial_parse(parser.parse_recovering(), noexec, &who, &script_content) {
                 Ok(s) => s,
                 Err(e) => {
                     return Ok(ExecResult::err(
-                        format!("{}: syntax error: {}\n", shell_name, e),
+                        nested_syntax_report(&e, &who, &script_content),
                         2,
                     ));
                 }
@@ -5752,11 +5855,13 @@ impl Interpreter {
                 .await
             })
             .await;
-            match parse_result.map(|r| r.map(|p| nested_partial_parse(p, noexec, shell_name))) {
+            match parse_result
+                .map(|r| r.map(|p| nested_partial_parse(p, noexec, &who, &script_content)))
+            {
                 Ok(Ok(Ok(s))) => s,
                 Ok(Ok(Err(e))) => {
                     return Ok(ExecResult::err(
-                        format!("{}: syntax error: {}\n", shell_name, e),
+                        nested_syntax_report(&e, &who, &script_content),
                         2,
                     ));
                 }
@@ -5820,6 +5925,7 @@ impl Interpreter {
         let child_snapshot = self.snapshot_subshell_state();
         // A new shell starts at subshell level 0.
         self.bash_subshell = 0;
+        self.xtrace_depth = 0;
         let shlvl_warning = self.reset_state_for_child_shell();
         // Output the `bash` command's own redirects will route must not stream
         // from the child first (`bash -c 'echo x >&2' 2>/dev/null` printed x),
@@ -5917,7 +6023,7 @@ impl Interpreter {
                     exec_result.stderr =
                         crate::StreamData::from(warning + &exec_result.stderr.text_lossy());
                 }
-                self.apply_redirections(exec_result, redirects).await
+                Ok(exec_result)
             }
             Err(e) => Err(e),
         }
@@ -6990,6 +7096,16 @@ impl Interpreter {
                 match &assignment.value {
                     AssignmentValue::Scalar(word) => {
                         let value = self.expand_word(word).await?;
+                        if self.is_xtrace_enabled() {
+                            // `+ v=x`, `+ a[1]='a b'`, `+ v+=y`
+                            let prefix = self.xtrace_prefix().await;
+                            let body = format!(
+                                "{}={}",
+                                Self::xtrace_assignment_lhs(assignment),
+                                xtrace::quote_value(&value)
+                            );
+                            self.queue_xtrace_line(&prefix, &body);
+                        }
                         let target = match self.resolve_nameref_strict(&assignment.name) {
                             Ok(t) => t,
                             Err(()) => {
@@ -7029,6 +7145,19 @@ impl Interpreter {
                         }
                     }
                     AssignmentValue::Array(words) => {
+                        if self.is_xtrace_enabled() {
+                            // bash traces the list as written, before
+                            // expanding it: `+ a=(x 'y z' $(cmd))`.
+                            let prefix = self.xtrace_prefix().await;
+                            let list: Vec<String> =
+                                words.iter().map(crate::parser::word_text).collect();
+                            let body = format!(
+                                "{}=({})",
+                                Self::xtrace_assignment_lhs(assignment),
+                                list.join(" ")
+                            );
+                            self.queue_xtrace_line(&prefix, &body);
+                        }
                         let arr_name = match self.resolve_nameref_strict(&assignment.name) {
                             Ok(n) => n,
                             Err(()) => {
@@ -7054,6 +7183,20 @@ impl Interpreter {
         })
     }
 
+    /// `name`, `name[i]` or `name+` as an xtrace assignment line shows it.
+    fn xtrace_assignment_lhs(assignment: &Assignment) -> String {
+        let mut lhs = assignment.name.clone();
+        if let Some(index) = &assignment.index {
+            lhs.push('[');
+            lhs.push_str(index);
+            lhs.push(']');
+        }
+        if assignment.append {
+            lhs.push('+');
+        }
+        lhs
+    }
+
     /// Try alias expansion. Returns `Some(result)` if alias was expanded, `None` otherwise.
     async fn try_alias_expansion(
         &mut self,
@@ -7184,6 +7327,7 @@ impl Interpreter {
             let snapshot = Box::new(self.snapshot_subshell_state());
             let last_exit_code = self.last_exit_code;
             self.bash_subshell += 1;
+            self.xtrace_depth += 1;
             let mut run = Ok(());
             for cmd in &commands {
                 let prev_stdin = self.pipeline_stdin.take();
@@ -7229,31 +7373,85 @@ impl Interpreter {
         }
     }
 
-    /// Build an xtrace line for `set -x` output.
-    fn build_xtrace_line(&self, name: &str, args: &[String]) -> Option<String> {
-        if !self.is_xtrace_enabled() {
-            return None;
-        }
-        let ps4 = self
-            .scoped
-            .variables
-            .get("PS4")
-            .cloned()
-            .unwrap_or_else(|| "+ ".to_string());
-        let mut trace = ps4;
-        trace.push_str(name);
-        for expanded in args {
-            trace.push(' ');
-            if expanded.contains(' ') || expanded.contains('\t') || expanded.is_empty() {
-                trace.push('\'');
-                trace.push_str(&expanded.replace('\'', "'\\''"));
-                trace.push('\'');
+    /// `set -x` line prefix: PS4 expanded like bash's prompt strings
+    /// (double-quote rules, tracing off, `$?` kept), its first character
+    /// repeated once per nesting level. Boxed: callers include
+    /// `execute_simple_command`, whose frame must stay small (TM-DOS-089).
+    fn xtrace_prefix<'a>(
+        &'a mut self,
+    ) -> std::pin::Pin<Box<dyn std::future::Future<Output = String> + Send + 'a>> {
+        Box::pin(async move {
+            // Never set: bash's default. (bash prints no prefix after an
+            // explicit `unset PS4`; bashkit does not seed PS4, so it cannot
+            // tell the two apart.)
+            let ps4 = self
+                .scoped
+                .variables
+                .get("PS4")
+                .cloned()
+                .unwrap_or_else(|| "+ ".to_string());
+            let expanded = if ps4.contains(['$', '`']) {
+                let word = Parser::parse_word_string_with_limits(
+                    &ps4,
+                    self.limits.max_ast_depth,
+                    self.limits.max_parser_operations,
+                );
+                let saved_exit = self.last_exit_code;
+                let saved_nounset = self.nounset_error.take();
+                let traced = self.flags.contains(BashFlags::XTRACE);
+                self.flags.remove(BashFlags::XTRACE);
+                let expanded = self.expand_word(&word).await;
+                self.flags.set(BashFlags::XTRACE, traced);
+                self.nounset_error = saved_nounset;
+                self.last_exit_code = saved_exit;
+                expanded.unwrap_or(ps4)
             } else {
-                trace.push_str(expanded);
+                ps4
+            };
+            xtrace::prefix(&expanded, self.xtrace_depth + 1)
+        })
+    }
+
+    /// Queue one `set -x` line with the pending `$(...)` stderr, so it is
+    /// written after the substitutions that built it and before the
+    /// command's own redirections apply.
+    fn queue_xtrace_line(&mut self, prefix: &str, body: &str) {
+        let line = format!("{prefix}{body}\n");
+        self.queue_subst_stderr(&line.into());
+    }
+
+    /// Trace a simple command's expanded words (`+ echo 'a b'`). Boxed for
+    /// `execute_simple_command`'s frame (TM-DOS-089).
+    fn trace_simple_command<'a>(
+        &'a mut self,
+        name: &'a str,
+        args: &'a [String],
+    ) -> std::pin::Pin<Box<dyn std::future::Future<Output = ()> + Send + 'a>> {
+        Box::pin(async move {
+            let prefix = self.xtrace_prefix().await;
+            let mut body = String::from(xtrace::quote_word(name));
+            for arg in args {
+                body.push(' ');
+                // `declare -a a=(1 2)` operand placeholder: bash traces the
+                // declaration as `declare -a a`.
+                if arg.contains(declare::COMPOUND_MARK) {
+                    let name = arg.split('=').next().unwrap_or(arg);
+                    body.push_str(name.trim_end_matches('+'));
+                } else {
+                    body.push_str(&xtrace::quote_word(arg));
+                }
             }
-        }
-        trace.push('\n');
-        Some(trace)
+            self.queue_xtrace_line(&prefix, &body);
+            // A function body, `eval` and `source` stream their own output as
+            // they run, which makes the enclosing list skip streaming this
+            // command's result: write the queued lines now (they stay queued
+            // for the returned result).
+            if matches!(name, "eval" | "source" | ".") || self.scoped.functions.contains_key(name) {
+                let pending = self.subst_stderr.clone();
+                let before = self.output_emit_count;
+                self.maybe_emit_output(&crate::StreamData::new(), &pending, before);
+            }
+        })
     }
 
     // THREAT[TM-DOS-089]: Box the full simple-command path because nested
@@ -7469,7 +7667,9 @@ impl Interpreter {
                 return self.apply_redirections(result, &command.redirects).await;
             }
 
-            let xtrace_line = self.build_xtrace_line(&name, &args);
+            if self.is_xtrace_enabled() {
+                self.trace_simple_command(&name, &args).await;
+            }
 
             let result = self
                 .execute_dispatched_command(&name, args, command, stdin)
@@ -7501,17 +7701,7 @@ impl Interpreter {
                 })
             };
 
-            // Prepend xtrace to stderr
-            let mut result = if let Some(trace) = xtrace_line {
-                result.map(|mut r| {
-                    let mut stderr: crate::StreamData = trace.into();
-                    stderr.append(&r.stderr);
-                    r.stderr = stderr;
-                    r
-                })
-            } else {
-                result
-            };
+            let mut result = result;
 
             self.run_deferred_proc_subs_from(deferred_proc_sub_start, &mut result)
                 .await?;
@@ -8966,13 +9156,9 @@ impl Interpreter {
             Ok(script) => script,
             Err(crate::error::Error::Parse { message, line, .. }) => {
                 // Like bash: the sourced file names itself, with the line.
-                let message = if message.starts_with("syntax error") {
-                    message
-                } else {
-                    format!("syntax error: {message}")
-                };
-                let result =
-                    ExecResult::err(format!("{filename}: line {}: {message}\n", line.max(1)), 2);
+                let report =
+                    crate::error::syntax_report(filename, &content, &message, line.max(1), 0);
+                let result = ExecResult::err(report, 2);
                 return self.redirect_result(result, redirects).await;
             }
             Err(e) => return Err(e),
@@ -9021,7 +9207,9 @@ impl Interpreter {
         self.return_depth += 1;
         self.source_depth += 1;
         let emit_before = self.output_emit_count;
+        self.xtrace_depth += 1;
         let mut exec_result = self.execute_script_body(&script, false, true).await;
+        self.xtrace_depth -= 1;
         if let Ok(r) = &mut exec_result {
             Box::pin(self.run_return_trap(r, emit_before)).await;
         }
@@ -9081,18 +9269,10 @@ impl Interpreter {
             Err(crate::error::Error::Parse { message, line, .. }) => {
                 // Like bash: status 2, line counted from the eval's own line, then
                 // the offending source line. Redirects still apply (`2>&1`).
-                let at = self.current_line + line.max(1) - 1;
-                let src = cmd.lines().nth(line.max(1) - 1).unwrap_or("");
-                let message = if message.starts_with("syntax error") {
-                    message
-                } else {
-                    format!("syntax error: {message}")
-                };
-                let who = self.diag_name();
-                let result = ExecResult::err(
-                    format!("{who}: eval: line {at}: {message}\n{who}: eval: line {at}: `{src}'\n"),
-                    2,
-                );
+                let who = format!("{}: eval", self.diag_name());
+                let shift = self.current_line.saturating_sub(1);
+                let report = crate::error::syntax_report(&who, &cmd, &message, line.max(1), shift);
+                let result = ExecResult::err(report, 2);
                 return self.redirect_result(result, redirects).await;
             }
             Err(e) => return Err(e),
@@ -9113,7 +9293,9 @@ impl Interpreter {
         // (`$LINENO`, diagnostics), not from 1.
         let saved_line_base =
             std::mem::replace(&mut self.line_base, self.current_line.saturating_sub(1));
+        self.xtrace_depth += 1;
         let result = self.execute_script_body(&script, false, true).await;
+        self.xtrace_depth -= 1;
         self.line_base = saved_line_base;
         let mut result = result?;
 
@@ -10701,6 +10883,7 @@ impl Interpreter {
             let snapshot = Box::new(self.snapshot_subshell_state());
             let last_exit_code = self.last_exit_code;
             self.bash_subshell += 1;
+            self.xtrace_depth += 1;
             let mut failed = None;
             for cmd in commands {
                 match self.execute_command(cmd).await {
@@ -10762,6 +10945,7 @@ impl Interpreter {
             last_bg_pid: self.last_bg_pid.clone(),
             seconds_base: self.seconds_base,
             bash_subshell: self.bash_subshell,
+            xtrace_depth: self.xtrace_depth,
             err_trap_dormant: self.err_trap_dormant,
             line_base: self.line_base,
         }
@@ -10789,6 +10973,7 @@ impl Interpreter {
         self.last_bg_pid = snap.last_bg_pid;
         self.seconds_base = snap.seconds_base;
         self.bash_subshell = snap.bash_subshell;
+        self.xtrace_depth = snap.xtrace_depth;
         self.err_trap_dormant = snap.err_trap_dormant;
         self.line_base = snap.line_base;
     }
@@ -11005,6 +11190,7 @@ impl Interpreter {
             // mutable state so mutations don't leak to the parent.
             let snapshot = self.snapshot_subshell_state();
             self.bash_subshell += 1;
+            self.xtrace_depth += 1;
             self.enter_subshell_err_scope();
             // The outer command's queued stderr must not pass through the
             // substitution's own redirects (`$(cmd 2>&1)`).
@@ -12108,7 +12294,9 @@ impl Interpreter {
                 let saved_exit = self.last_exit_code;
                 self.in_trap = true;
                 let emit_before = self.output_emit_count;
+                self.xtrace_depth += 1;
                 let result = self.execute_command_sequence(&trap_script.commands).await;
+                self.xtrace_depth -= 1;
                 self.in_trap = false;
                 self.last_exit_code = saved_exit;
                 if let Ok(trap_result) = result {
@@ -12144,7 +12332,9 @@ impl Interpreter {
         let saved_line_base =
             std::mem::replace(&mut self.line_base, self.current_line.saturating_sub(1));
         let emit_before = self.output_emit_count;
+        self.xtrace_depth += 1;
         let result = self.execute_command_sequence(&trap_script.commands).await;
+        self.xtrace_depth -= 1;
         self.line_base = saved_line_base;
         self.in_trap = was_in_trap;
         let Ok(trap_result) = result else {
diff --git a/crates/bashkit/src/interpreter/time_command.rs b/crates/bashkit/src/interpreter/time_command.rs
index 3f007bd89..9471bc5d2 100644
--- a/crates/bashkit/src/interpreter/time_command.rs
+++ b/crates/bashkit/src/interpreter/time_command.rs
@@ -149,6 +149,64 @@ fn push_time_char(output: &mut String, value: char, max_bytes: usize) -> Result<
     Ok(())
 }
 
+/// The reserved word's report under `TIMEFORMAT` (bash
+/// `print_formatted_time`): `%[p][l]R` is the elapsed time with `p` (0-3,
+/// default 3) truncated decimals, `l` as `XmY.YYYs`; `%%` is `%`. Host CPU
+/// fields (`%U`, `%S`, `%P`) say `unavailable` like every other report. A
+/// newline follows; an empty format prints nothing. `Err` carries an
+/// invalid format character (bash warns and prints no report).
+pub(super) fn render_timeformat(
+    format: &str,
+    elapsed: std::time::Duration,
+) -> Result<String, char> {
+    if format.is_empty() {
+        return Ok(String::new());
+    }
+    let mut out = String::with_capacity(format.len() + 16);
+    let mut chars = format.chars().peekable();
+    while let Some(ch) = chars.next() {
+        if ch != '%' || chars.peek().is_none() {
+            out.push(ch);
+            continue;
+        }
+        let mut prec = 3u32;
+        let mut long = false;
+        if let Some(d) = chars.peek().and_then(|c| c.to_digit(10)) {
+            prec = d.min(3);
+            chars.next();
+        }
+        if chars.peek() == Some(&'l') {
+            long = true;
+            chars.next();
+        }
+        match chars.next() {
+            Some('%') => out.push('%'),
+            Some('R') => {
+                let mut secs = elapsed.as_secs();
+                if long {
+                    out.push_str(&format!("{}m", secs / 60));
+                    secs %= 60;
+                }
+                out.push_str(&secs.to_string());
+                if prec > 0 {
+                    let millis = elapsed.subsec_millis();
+                    let digits = format!("{millis:03}");
+                    out.push('.');
+                    out.push_str(&digits[..prec as usize]);
+                }
+                if long {
+                    out.push('s');
+                }
+            }
+            Some('U' | 'S' | 'P') => out.push_str("unavailable"),
+            Some(other) => return Err(other),
+            None => return Err('%'),
+        }
+    }
+    out.push('\n');
+    Ok(out)
+}
+
 pub(super) fn verbose_time_report(usage: &TimeUsage) -> String {
     format!(
         "Elapsed (wall clock) time: {:.2}\n\
@@ -173,3 +231,23 @@ pub(super) fn sanitize_time_path(path: &str) -> String {
         .map(|ch| if ch.is_control() { '?' } else { ch })
         .collect()
 }
+
+#[cfg(test)]
+mod tests {
+    use super::render_timeformat;
+    use std::time::Duration;
+
+    #[test]
+    fn timeformat_precision_and_long_form() {
+        let d = Duration::from_millis(61_234);
+        assert_eq!(render_timeformat("%R", d).unwrap(), "61.234\n");
+        assert_eq!(render_timeformat("%0R", d).unwrap(), "61\n");
+        assert_eq!(render_timeformat("%2lR", d).unwrap(), "1m1.23s\n");
+        assert_eq!(
+            render_timeformat("%9R|%%|%U", d).unwrap(),
+            "61.234|%|unavailable\n"
+        );
+        assert_eq!(render_timeformat("", d).unwrap(), "");
+        assert_eq!(render_timeformat("%Q", d), Err('Q'));
+    }
+}
diff --git a/crates/bashkit/src/interpreter/xtrace.rs b/crates/bashkit/src/interpreter/xtrace.rs
new file mode 100644
index 000000000..a2a4ffd38
--- /dev/null
+++ b/crates/bashkit/src/interpreter/xtrace.rs
@@ -0,0 +1,214 @@
+//! `set -x` trace text, as bash 5.2 prints it.
+//!
+//! Important decisions:
+//! - Words are quoted with bash's own rules (`print_cmd.c`
+//!   `xtrace_print_word_list`, `lib/sh/shquote.c`): empty → `''`, a shell
+//!   metacharacter → single quotes, a non-printable character → `$'...'`,
+//!   anything else verbatim. Assignment values use the same rules except that
+//!   an empty value stays empty (`+ v=`).
+//! - The line prefix is PS4 after expansion, its first character repeated
+//!   once per nesting level (`$(...)`, `eval`, `source`, trap handlers),
+//!   like bash's `indirection_level_string`. Expansion lives in the
+//!   interpreter (it is async); this module only formats.
+//! - Trace lines are queued with the pending `$(...)` stderr, so a
+//!   substitution's own trace (`++ echo sub`) comes before the line of the
+//!   command that expanded it, and a command's trace is written before its
+//!   redirections apply (`echo x 2>/dev/null` still traces).
+
+use std::borrow::Cow;
+
+/// bash `sh_contains_shell_metas`: does `s` need quoting to be re-read as
+/// one word?
+fn contains_shell_metas(s: &str) -> bool {
+    let bytes = s.as_bytes();
+    for (i, &b) in bytes.iter().enumerate() {
+        match b {
+            b' ' | b'\t' | b'\n' | b'\'' | b'"' | b'\\' | b'|' | b'&' | b';' | b'(' | b')'
+            | b'<' | b'>' | b'!' | b'{' | b'}' | b'*' | b'[' | b'?' | b']' | b'^' | b'$' | b'`' => {
+                return true;
+            }
+            b'~' if i == 0 || bytes[i - 1] == b'=' || bytes[i - 1] == b':' => return true,
+            b'#' if i == 0 => return true,
+            _ => {}
+        }
+    }
+    false
+}
+
+/// bash `ansic_shouldquote`: any non-printable character.
+fn should_ansic_quote(s: &str) -> bool {
+    s.chars().any(|c| c.is_control())
+}
+
+/// bash `sh_single_quote`.
+fn single_quote(s: &str) -> String {
+    if s == "'" {
+        return "\\'".to_string();
+    }
+    let mut out = String::with_capacity(s.len() + 2);
+    out.push('\'');
+    for c in s.chars() {
+        if c == '\'' {
+            out.push_str("'\\''");
+        } else {
+            out.push(c);
+        }
+    }
+    out.push('\'');
+    out
+}
+
+/// bash `ansic_quote`: `$'...'` with C escapes, octal for other controls.
+fn ansic_quote(s: &str) -> String {
+    let mut out = String::with_capacity(s.len() + 3);
+    out.push_str("$'");
+    for c in s.chars() {
+        let esc = match c {
+            '\x1b' => Some('E'),
+            '\x07' => Some('a'),
+            '\x0b' => Some('v'),
+            '\x08' => Some('b'),
+            '\x0c' => Some('f'),
+            '\n' => Some('n'),
+            '\r' => Some('r'),
+            '\t' => Some('t'),
+            '\\' | '\'' => Some(c),
+            _ => None,
+        };
+        if let Some(e) = esc {
+            out.push('\\');
+            out.push(e);
+        } else if c.is_control() {
+            let mut buf = [0u8; 4];
+            for b in c.encode_utf8(&mut buf).bytes() {
+                out.push_str(&format!("\\{b:03o}"));
+            }
+        } else {
+            out.push(c);
+        }
+    }
+    out.push('\'');
+    out
+}
+
+/// One traced word of a simple command.
+pub(super) fn quote_word(s: &str) -> Cow<'_, str> {
+    if s.is_empty() {
+        Cow::Borrowed("''")
+    } else {
+        quote_value(s)
+    }
+}
+
+/// An assignment value (`+ v=`, `+ v='a b'`): empty stays empty.
+pub(super) fn quote_value(s: &str) -> Cow<'_, str> {
+    if contains_shell_metas(s) {
+        Cow::Owned(single_quote(s))
+    } else if should_ansic_quote(s) {
+        Cow::Owned(ansic_quote(s))
+    } else {
+        Cow::Borrowed(s)
+    }
+}
+
+/// The trace prefix from an expanded PS4: its first character repeated
+/// `level` times (at least once), then the rest. An empty PS4 gives none.
+pub(super) fn prefix(ps4: &str, level: usize) -> String {
+    let mut chars = ps4.chars();
+    let Some(first) = chars.next() else {
+        return String::new();
+    };
+    let mut out = String::with_capacity(ps4.len() + level);
+    for _ in 0..level.max(1) {
+        out.push(first);
+    }
+    out.push_str(chars.as_str());
+    out
+}
+
+/// One `[[ ]]` primary as bash traces it (`xtrace_print_cond_term`):
+/// operands unquoted, an empty one as `''`, a lone word as `-n word`.
+pub(super) fn cond_term(invert: bool, args: &[String]) -> String {
+    let show = |s: &str| -> String {
+        if s.is_empty() {
+            "''".to_string()
+        } else {
+            s.to_string()
+        }
+    };
+    let mut out = String::from("[[ ");
+    if invert {
+        out.push_str("! ");
+    }
+    match args {
+        [word] => {
+            out.push_str("-n ");
+            out.push_str(&show(word));
+        }
+        [op, arg] => {
+            out.push_str(op);
+            out.push(' ');
+            out.push_str(&show(arg));
+        }
+        [lhs, op, rhs] => {
+            out.push_str(&show(lhs));
+            out.push(' ');
+            out.push_str(op);
+            out.push(' ');
+            out.push_str(&show(rhs));
+        }
+        other => {
+            let words: Vec<String> = other.iter().map(|w| show(w)).collect();
+            out.push_str(&words.join(" "));
+        }
+    }
+    out.push_str(" ]]");
+    out
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn words_quote_like_bash() {
+        assert_eq!(quote_word("plain"), "plain");
+        assert_eq!(quote_word(""), "''");
+        assert_eq!(quote_word("a b"), "'a b'");
+        assert_eq!(quote_word("it's"), "'it'\\''s'");
+        assert_eq!(quote_word("'"), "\\'");
+        assert_eq!(quote_word("*"), "'*'");
+        assert_eq!(quote_word("a#"), "a#");
+        assert_eq!(quote_word("#a"), "'#a'");
+        assert_eq!(quote_word("~a"), "'~a'");
+        assert_eq!(quote_word("a~"), "a~");
+        assert_eq!(quote_word("a=~b"), "'a=~b'");
+        assert_eq!(quote_word("tab\there"), "'tab\there'");
+        assert_eq!(quote_word("\x01x"), "$'\\001x'");
+        assert_eq!(quote_word("\x1b"), "$'\\E'");
+        assert_eq!(quote_word("é"), "é");
+    }
+
+    #[test]
+    fn empty_value_stays_bare() {
+        assert_eq!(quote_value(""), "");
+        assert_eq!(quote_value("x y"), "'x y'");
+    }
+
+    #[test]
+    fn prefix_repeats_first_char() {
+        assert_eq!(prefix("+ ", 1), "+ ");
+        assert_eq!(prefix("+ ", 3), "+++ ");
+        assert_eq!(prefix("+ [3] ", 2), "++ [3] ");
+        assert_eq!(prefix("", 2), "");
+        assert_eq!(prefix("é>", 2), "éé>");
+    }
+
+    #[test]
+    fn cond_terms() {
+        let s = |v: &[&str]| v.iter().map(|x| x.to_string()).collect::<Vec<_>>();
+        assert_eq!(cond_term(false, &s(&["abc"])), "[[ -n abc ]]");
+        assert_eq!(cond_term(true, &s(&["-z", "abc"])), "[[ ! -z abc ]]");
+        assert_eq!(cond_term(false, &s(&["", "==", "a b"])), "[[ '' == a b ]]");
+    }
+}
diff --git a/crates/bashkit/src/lib.rs b/crates/bashkit/src/lib.rs
index 5a7cd3cba..c09e16992 100644
--- a/crates/bashkit/src/lib.rs
+++ b/crates/bashkit/src/lib.rs
@@ -1063,6 +1063,13 @@ impl Bash {
             "Parsing script"
         );
 
+        // A syntax error after runnable commands is reported as bash reports
+        // one in a script: `$0: line N: ...`.
+        let syntax_who = invocation
+            .arg0
+            .clone()
+            .unwrap_or_else(|| self.interpreter.diag_name());
+
         // Important decision: skip the tokio `spawn_blocking` + `time::timeout`
         // round-trip for small scripts. The parser already enforces a fuel
         // budget via `max_parser_operations`, so a runaway script still
@@ -1086,7 +1093,7 @@ impl Bash {
                 Some(parser_timeout),
             )
             .with_execution_budget(self.interpreter.execution_budget().clone());
-            recover_partial_parse(parser.parse_recovering())?
+            recover_partial_parse(parser.parse_recovering(), &syntax_who, script)?
         };
 
         // On native targets, parse inline for small scripts (avoid threadpool
@@ -1096,7 +1103,7 @@ impl Bash {
         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());
-            match recover_partial_parse(parser.parse_recovering()) {
+            match recover_partial_parse(parser.parse_recovering(), &syntax_who, script) {
                 Ok(ast) => {
                     #[cfg(feature = "logging")]
                     tracing::debug!(target: "bashkit::parser", "Parse completed (inline)");
@@ -1111,12 +1118,13 @@ impl Bash {
         } else {
             let script_owned = script.to_owned();
             let execution_budget = self.interpreter.execution_budget().clone();
+            let who = syntax_who.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);
-                    recover_partial_parse(parser.parse_recovering())
+                    recover_partial_parse(parser.parse_recovering(), &who, &script_owned)
                 })
                 .await
             })
@@ -4244,12 +4252,17 @@ pub mod hooks_guide {}
 /// unaffected.
 fn recover_partial_parse(
     (mut script, error): (parser::Script, Option<Error>),
+    who: &str,
+    source: &str,
 ) -> Result<parser::Script> {
     match error {
         None => Ok(script),
         Some(e) if script.commands.is_empty() => Err(e),
         Some(e) => {
-            script.trailing_error = Some(format!("bash: syntax error: {e}\n"));
+            let report = e
+                .syntax_report(who, source)
+                .unwrap_or_else(|| format!("{who}: syntax error: {e}\n"));
+            script.trailing_error = Some(report);
             Ok(script)
         }
     }
@@ -7212,11 +7225,10 @@ echo missing fi"#,
         let result = result.unwrap();
         assert_eq!(result.stdout, "ok\n");
         assert_eq!(result.exit_code, 2);
-        // Error should mention line number
-        assert!(
-            result.stderr.contains("line") && result.stderr.contains("parse"),
-            "Error should be a parse error: {}",
-            result.stderr
+        // Reported like bash: on the line after the last.
+        assert_eq!(
+            result.stderr,
+            "bash: line 4: syntax error: unexpected end of file\n"
         );
     }
 
@@ -7794,6 +7806,13 @@ echo missing fi"#,
         assert_streaming_equivalence("echo out; echo err >&2; echo out2").await;
     }
 
+    #[tokio::test]
+    async fn test_streaming_equivalence_xtrace_function_and_eval() {
+        // The call's own trace line streams before the body's output; it
+        // used to vanish from the stream once the body emitted.
+        assert_streaming_equivalence("set -x; f() { echo in; }; f a; eval 'echo ev'; x=$(f)").await;
+    }
+
     #[tokio::test]
     async fn test_streaming_equivalence_pipeline() {
         assert_streaming_equivalence("echo -e 'a\\nb\\nc' | grep b").await;
diff --git a/crates/bashkit/src/parser/lexer.rs b/crates/bashkit/src/parser/lexer.rs
index 0fdf85fc9..f22f1b113 100644
--- a/crates/bashkit/src/parser/lexer.rs
+++ b/crates/bashkit/src/parser/lexer.rs
@@ -2324,6 +2324,13 @@ impl<'a> Lexer<'a> {
     /// backslashes are kept verbatim for the caller to interpret. Returns
     /// `None` when no operand follows.
     pub fn read_cond_regex(&mut self) -> Option<String> {
+        self.read_cond_regex_checked().0
+    }
+
+    /// [`Self::read_cond_regex`], also telling whether input ran out inside
+    /// an unclosed `(` group (bash: `unexpected EOF while looking for
+    /// matching `)'`).
+    pub(crate) fn read_cond_regex_checked(&mut self) -> (Option<String>, bool) {
         while matches!(self.peek_char(), Some(' ' | '\t')) {
             self.advance();
         }
@@ -2384,7 +2391,7 @@ impl<'a> Lexer<'a> {
                 _ => {}
             }
         }
-        (!raw.is_empty()).then_some(raw)
+        ((!raw.is_empty()).then_some(raw), depth > 0)
     }
 
     fn is_word_char(&self, ch: char) -> bool {
diff --git a/crates/bashkit/src/parser/mod.rs b/crates/bashkit/src/parser/mod.rs
index 18c262734..00c7a60b9 100644
--- a/crates/bashkit/src/parser/mod.rs
+++ b/crates/bashkit/src/parser/mod.rs
@@ -8,6 +8,11 @@
 //! position - when they would start a command. In argument position, they are regular
 //! words. The termination of compound commands is handled by `parse_compound_list_until`
 //! which checks for terminators BEFORE parsing each command.
+//!
+//! Grammar errors are worded the way bash words them, by the token the parse
+//! stopped at (see `Parser::error`): `syntax error near unexpected token
+//! `fi'`, or `syntax error: unexpected end of file` reported on the line after
+//! the last when the input ran out inside a construct.
 
 // Parser uses chars().next().unwrap() after validating character presence.
 // This is safe because we check bounds before accessing.
@@ -26,6 +31,7 @@ pub use ast::*;
 pub use budget::{BudgetError, validate as validate_budget};
 pub use lexer::{Lexer, SpannedToken};
 pub use print_cmd::function_string;
+pub(crate) use print_cmd::word_text;
 pub use span::{Position, Span};
 
 use crate::error::{Error, Result};
@@ -177,8 +183,14 @@ impl<'a> Parser<'a> {
         parser.parse_word(input.to_string())
     }
 
-    /// Create a parse error with the current position.
+    /// Create a parse error with the current position. A grammar error
+    /// (a construct that cannot continue with the current token) gets bash's
+    /// wording instead of `message`; see [`Self::bash_grammar_error`].
     fn error(&self, message: impl Into<String>) -> Error {
+        let message = message.into();
+        if let Some(err) = self.bash_grammar_error(&message) {
+            return err;
+        }
         Error::parse_at(
             message,
             self.current_span.start.line,
@@ -186,6 +198,48 @@ impl<'a> Parser<'a> {
         )
     }
 
+    /// bash reports a grammar error by the token it stopped at: `syntax error
+    /// near unexpected token `T'` (a line end is `newline`), or, when input
+    /// ran out inside an unfinished construct, `syntax error: unexpected end
+    /// of file` on the line after the last one.
+    fn bash_grammar_error(&self, message: &str) -> Option<Error> {
+        // Constructs that may continue on later lines: running out of input
+        // is an unexpected end of file.
+        // (`f(` must close on its own line: bash stops at `newline`.)
+        let unfinished = message.starts_with("syntax error: empty ")
+            || (message.starts_with("expected '") && !message.ends_with("function definition"))
+            || message.starts_with("expected command after");
+        if !unfinished
+            && !message.starts_with("unexpected token")
+            && !message.starts_with("expected '")
+        {
+            return None;
+        }
+        let line = self.current_span.start.line;
+        let near = |token: &str| {
+            Some(Error::parse_at(
+                format!("syntax error near unexpected token `{token}'"),
+                line,
+                self.current_span.start.column,
+            ))
+        };
+        match &self.current_token {
+            None if unfinished => Some(Error::parse_at(
+                "syntax error: unexpected end of file",
+                self.input.lines().count() + 1,
+                1,
+            )),
+            None | Some(tokens::Token::Newline) => near("newline"),
+            Some(_) => {
+                let span = self.current_span;
+                match self.input.get(span.start.offset..span.end.offset) {
+                    Some(text) if !text.is_empty() => near(text),
+                    _ => None,
+                }
+            }
+        }
+    }
+
     fn current_command_end_offset(&self) -> usize {
         if self.current_token.is_some() {
             self.current_span.start.offset
@@ -289,6 +343,17 @@ impl<'a> Parser<'a> {
     /// Check if current token is an error token and return the error if so
     fn check_error_token(&self) -> Result<()> {
         if let Some(tokens::Token::Error(msg)) = &self.current_token {
+            // bash: `unexpected EOF while looking for matching `"'`.
+            let close = match msg.as_str() {
+                "unterminated double quote" => Some('"'),
+                "unterminated single quote" => Some('\''),
+                _ => None,
+            };
+            if let Some(close) = close {
+                return Err(self.error(format!(
+                    "unexpected EOF while looking for matching `{close}'"
+                )));
+            }
             return Err(self.error(format!("syntax error: {}", msg)));
         }
         Ok(())
@@ -899,6 +964,11 @@ impl<'a> Parser<'a> {
 
         // Parse condition
         let condition = self.parse_compound_list("then")?;
+        if condition.is_empty() {
+            // bash: `if then` stops at `then`.
+            self.pop_depth();
+            return Err(self.error("syntax error: empty if condition"));
+        }
 
         // Expect 'then'
         self.expect_keyword("then")?;
@@ -920,6 +990,10 @@ impl<'a> Parser<'a> {
             self.skip_newlines()?;
 
             let elif_condition = self.parse_compound_list("then")?;
+            if elif_condition.is_empty() {
+                self.pop_depth();
+                return Err(self.error("syntax error: empty elif condition"));
+            }
             self.expect_keyword("then")?;
             self.skip_newlines()?;
 
@@ -1339,6 +1413,10 @@ impl<'a> Parser<'a> {
 
         // Parse condition
         let condition = self.parse_compound_list("do")?;
+        if condition.is_empty() {
+            self.pop_depth();
+            return Err(self.error("syntax error: empty while condition"));
+        }
 
         // Expect 'do'
         self.expect_keyword("do")?;
@@ -1373,6 +1451,10 @@ impl<'a> Parser<'a> {
 
         // Parse condition
         let condition = self.parse_compound_list("do")?;
+        if condition.is_empty() {
+            self.pop_depth();
+            return Err(self.error("syntax error: empty until condition"));
+        }
 
         // Expect 'do'
         self.expect_keyword("do")?;
@@ -1704,7 +1786,7 @@ impl<'a> Parser<'a> {
             self.current_token = Some(tokens::Token::RightParen);
         } else if !matches!(self.current_token, Some(tokens::Token::RightParen)) {
             self.pop_depth();
-            return Err(Error::parse("expected ')' to close subshell".to_string()));
+            return Err(self.error("expected ')' to close subshell"));
         } else {
             self.advance(); // consume ')'
         }
@@ -1732,9 +1814,7 @@ impl<'a> Parser<'a> {
 
         if !matches!(self.current_token, Some(tokens::Token::RightBrace)) {
             self.pop_depth();
-            return Err(Error::parse(
-                "expected '}' to close brace group".to_string(),
-            ));
+            return Err(self.error("expected '}' to close brace group"));
         }
 
         // Bash requires at least one command in a brace group
@@ -1798,7 +1878,23 @@ impl<'a> Parser<'a> {
                         // regex word, where `#`, `|` and spaces in groups are
                         // pattern text, not comments or operators.
                         words.push(Word::literal("=~"));
-                        if let Some(raw) = self.lexer.read_cond_regex() {
+                        let (raw, unclosed) = self.lexer.read_cond_regex_checked();
+                        if unclosed {
+                            // bash reads the group to end of input, then the
+                            // conditional grammar rejects the missing operand
+                            // there: two diagnostics, the second on the line
+                            // after the last.
+                            let eof_line = self.input.lines().count() + 1;
+                            return Err(Error::parse_at(
+                                format!(
+                                    "unexpected EOF while looking for matching `)'\n\
+                                     line {eof_line}: unexpected argument to conditional binary operator"
+                                ),
+                                self.current_span.start.line,
+                                self.current_span.start.column,
+                            ));
+                        }
+                        if let Some(raw) = raw {
                             let mut word = self.cond_regex_word(raw.clone());
                             word.raw = Some(raw.trim().to_string());
                             words.push(word);
diff --git a/crates/bashkit/src/parser/print_cmd.rs b/crates/bashkit/src/parser/print_cmd.rs
index 8cb098fd0..211fe8410 100644
--- a/crates/bashkit/src/parser/print_cmd.rs
+++ b/crates/bashkit/src/parser/print_cmd.rs
@@ -651,7 +651,7 @@ fn assignment_text(a: &Assignment) -> String {
 
 /// A word as written: its source text without line continuations, or a
 /// reconstruction when the parser did not record the source.
-fn word_text(w: &Word) -> String {
+pub(crate) fn word_text(w: &Word) -> String {
     match &w.raw {
         Some(raw) => normalize_raw_word(raw),
         None => reconstruct_word(w),
diff --git a/crates/bashkit/src/terminal/mod.rs b/crates/bashkit/src/terminal/mod.rs
index 32b2dcec9..2a70255d0 100644
--- a/crates/bashkit/src/terminal/mod.rs
+++ b/crates/bashkit/src/terminal/mod.rs
@@ -565,6 +565,7 @@ fn is_incomplete_input(msg: &str) -> bool {
     lower.contains("unterminated")
         || lower.contains("unexpected end of input")
         || lower.contains("unexpected eof")
+        || lower.contains("unexpected end of file")
         || lower.contains("syntax error: empty")
         || lower.contains("expected 'fi'")
         || lower.contains("expected 'done'")
diff --git a/crates/bashkit/tests/spec_cases/bash/parse-errors.test.sh b/crates/bashkit/tests/spec_cases/bash/parse-errors.test.sh
index 41b0bf2b7..af1dbf2ca 100644
--- a/crates/bashkit/tests/spec_cases/bash/parse-errors.test.sh
+++ b/crates/bashkit/tests/spec_cases/bash/parse-errors.test.sh
@@ -147,3 +147,82 @@ echo status=$?
 ### expect
 status=2
 ### end
+
+### syntax_error_near_unexpected_token
+# bash names the token the parse stopped at, then the line
+bash -c 'if then fi' 2>&1; echo rc=$?
+bash -c 'echo a; fi' 2>&1
+bash -c 'while do done' 2>&1
+bash -c 'a && && b' 2>&1
+bash -c 'echo (' 2>&1
+### expect
+bash: -c: line 1: syntax error near unexpected token `then'
+bash: -c: line 1: `if then fi'
+rc=2
+bash: -c: line 1: syntax error near unexpected token `fi'
+bash: -c: line 1: `echo a; fi'
+bash: -c: line 1: syntax error near unexpected token `do'
+bash: -c: line 1: `while do done'
+bash: -c: line 1: syntax error near unexpected token `&&'
+bash: -c: line 1: `a && && b'
+bash: -c: line 1: syntax error near unexpected token `newline'
+bash: -c: line 1: `echo ('
+### end
+
+### syntax_error_unexpected_end_of_file
+# input ending inside a construct: reported on the line after the last
+bash -c 'for x in; do' 2>&1; echo rc=$?
+bash -c 'if true; then' 2>&1
+bash -c '{ echo' 2>&1
+bash -c 'case x in' 2>&1
+printf 'echo 1\nif true; then\n' | bash 2>&1
+### expect
+bash: -c: line 2: syntax error: unexpected end of file
+rc=2
+bash: -c: line 2: syntax error: unexpected end of file
+bash: -c: line 2: syntax error: unexpected end of file
+bash: -c: line 2: syntax error: unexpected end of file
+1
+bash: line 3: syntax error: unexpected end of file
+### end
+
+### syntax_error_partial_run_and_eval
+# commands before the error run; eval counts from its own line
+bash -c $'echo first\nfor x in; do' 2>&1; echo rc=$?
+bash -c $'echo x\neval "if then fi"' 2>&1
+### expect
+first
+bash: -c: line 3: syntax error: unexpected end of file
+rc=2
+x
+bash: eval: line 2: syntax error near unexpected token `then'
+bash: eval: line 2: `if then fi'
+### end
+
+### syntax_error_unterminated_quote
+# an unterminated quote names the quote it looked for
+bash -c 'echo "a' 2>&1
+bash -c "echo 'a" 2>&1
+### expect
+bash: -c: line 1: unexpected EOF while looking for matching `"'
+bash: -c: line 1: unexpected EOF while looking for matching `''
+### end
+
+### syntax_error_dbracket_regex_unclosed_group
+# [[ =~ ( ]] reads the group to end of input, then the operand is missing
+bash -c '[[ abc =~ ( ]]' 2>&1; echo rc=$?
+### expect
+bash: -c: line 1: unexpected EOF while looking for matching `)'
+bash: -c: line 2: unexpected argument to conditional binary operator
+rc=2
+### end
+
+### bash_child_errors_follow_its_redirects
+# a child shell's syntax error and missing script obey the command's redirects
+{ bash -c 'if then fi' 2>/dev/null; } 2>&1; echo rc=$?
+{ bash -c 'echo "a' 2>/dev/null; } 2>&1
+{ bash /no/such/file 2>/dev/null; } 2>&1; echo rc=$?
+### expect
+rc=2
+rc=127
+### end
diff --git a/crates/bashkit/tests/spec_cases/bash/time.test.sh b/crates/bashkit/tests/spec_cases/bash/time.test.sh
index 6a3d65eac..d03d3dd4b 100644
--- a/crates/bashkit/tests/spec_cases/bash/time.test.sh
+++ b/crates/bashkit/tests/spec_cases/bash/time.test.sh
@@ -82,3 +82,15 @@ echo $?
 ### expect
 1
 ### end
+
+### time_timeformat_precision
+# TIMEFORMAT picks the report; %0R has no decimals
+TIMEFORMAT='t=%0R%%'
+{ time true; } 2>&1
+TIMEFORMAT=
+{ time true; } 2>&1
+echo end
+### expect
+t=0%
+end
+### end
diff --git a/crates/bashkit/tests/spec_cases/bash/xtrace.test.sh b/crates/bashkit/tests/spec_cases/bash/xtrace.test.sh
new file mode 100644
index 000000000..755edf0b8
--- /dev/null
+++ b/crates/bashkit/tests/spec_cases/bash/xtrace.test.sh
@@ -0,0 +1,77 @@
+# set -x trace text, compared against bash 5.2
+
+### xtrace_word_quoting
+# set -x quotes traced words the way bash re-reads them
+{ set -x; echo 'a b' '' "it's" '*' a# '#a' '~x' x~ "'" $'\001' 'a=~b'; set +x; } 2>&1 >/dev/null
+### expect
++ echo 'a b' '' 'it'\''s' '*' a# '#a' '~x' x~ \' $'\001' 'a=~b'
++ set +x
+### end
+
+### xtrace_assignments
+# assignments are traced; arrays as written, before expansion
+{ set -x; a=1; b="x y"; c=; arr=(1 'two 2' $(echo 3)); arr[3]=z; a+=2; set +x; } 2>&1
+### expect
++ a=1
++ b='x y'
++ c=
++ arr=(1 'two 2' $(echo 3))
+++ echo 3
++ arr[3]=z
++ a+=2
++ set +x
+### end
+
+### xtrace_prefix_assignment_and_redirect
+# prefix assignments trace first; the trace precedes the command's redirects
+{ set -x; V=1 echo hi 2>/dev/null; set +x; } 2>&1 >/dev/null
+### expect
++ V=1
++ echo hi
++ set +x
+### end
+
+### xtrace_ps4_expansion_and_nesting
+# PS4 is expanded; $(...) and eval repeat its first character
+f() { echo "in $1" >/dev/null; }
+{ PS4='+$((1+1)) '; set -x; x=$(echo sub); eval 'echo ev' >/dev/null; f 'a b'; set +x; } 2>&1
+### expect
+++2 echo sub
++2 x=sub
++2 eval 'echo ev'
+++2 echo ev
++2 f 'a b'
++2 echo 'in a b'
++2 set +x
+### end
+
+### xtrace_empty_ps4
+# an empty PS4 traces without a prefix
+{ PS4=''; set -x; echo quiet >/dev/null; set +x; } 2>&1
+### expect
+echo quiet
+set +x
+### end
+
+### xtrace_conditional_terms
+# [[ ]] traces each primary it evaluates
+{ set -x; [[ abc == a* && -n "" ]]; [[ ! -z x || y ]]; [[ $(echo hi) == hi ]]; set +x; } 2>&1
+### expect
++ [[ abc == a* ]]
++ [[ -n '' ]]
++ [[ ! -z x ]]
+++ echo hi
++ [[ hi == hi ]]
++ set +x
+### end
+
+### cond_negation_binds_tighter_than_or
+# ! applies to one primary, not the whole || list
+[[ ! -z x || y ]]; echo $?
+[[ ! -n x && y ]]; echo $?
+[[ ! ( -z x || y ) ]]; echo $?
+### expect
+0
+1
+1
+### end
diff --git a/knowledge/foundations/parser.md b/knowledge/foundations/parser.md
index 6a9f67cbe..ff1478c63 100644
--- a/knowledge/foundations/parser.md
+++ b/knowledge/foundations/parser.md
@@ -148,8 +148,20 @@ the error; `Bash::exec` and child `bash`/`sh` run them and then report the
 error via `Script::trailing_error` (stderr + exit 2), unless `exit` or
 `set -e` stopped the script first. With nothing runnable before the error,
 `exec` still returns `Err(Parse)`; the `bashkit` CLI maps that to
-`bash: syntax error: ...` on stderr and exit 2, so both cases exit 2 like
+bash's report (`Error::syntax_report`: `bash: -c: line N: ...` or
+`script.sh: line N: ...`) on stderr and exit 2, so both cases exit 2 like
 bash. `bash -n` keeps whole-script rejection.
+
+**Error wording.** `Parser::error` rewrites grammar errors (empty bodies,
+missing keywords, stray tokens) the way bash's yacc parser words them, by the
+token the parse stopped at: `syntax error near unexpected token `T'` (a line
+end is `newline`; the report adds the offending source line), or, when input
+ran out inside a construct, `syntax error: unexpected end of file` on line
+`lines + 1`. An empty `if`/`elif`/`while`/`until` condition fails at
+`then`/`do`, like bash. An unclosed `(` group in a `[[ =~ ]]` operand is read
+to end of input and gives bash's two diagnostics; a further diagnostic is a
+`line N: text` line inside the message. The REPL treats `unexpected end of
+file` as incomplete input.
 Deferred `$(...)` errors carry no reliable position, so they never run a
 prefix.
 
diff --git a/knowledge/log.md b/knowledge/log.md
index acc72fdb0..782756ae3 100644
--- a/knowledge/log.md
+++ b/knowledge/log.md
@@ -2,6 +2,7 @@
 
 ## 2026-10-07
 
+* **Fix**: stderr text matches bash for `set -x`, syntax errors and `TIMEFORMAT`. `set -x` quotes traced words like bash (`''`, `'a b'`, `\'`, `$'\001'`), traces assignments (`+ a=1`, `+ v=`, `+ arr=(1 $(x))` as written), function calls (the line used to vanish when streaming), `eval`/`source` and each `[[ ]]` primary (`+ [[ ! -z x ]]`); PS4 is expanded (`$LINENO`, `$(...)`, with tracing off) and its first character repeats per `$(...)`/`eval`/`source`/trap level (`++ echo sub`). Trace lines queue with the pending `$(...)` stderr, so they come after the substitutions that built them and before the command's redirects (`echo x 2>/dev/null` still traces). Grammar errors are worded by the token the parser stopped at: `syntax error near unexpected token `then'` plus the offending line, or `syntax error: unexpected end of file` on the line after the last; unterminated quotes read `unexpected EOF while looking for matching `"'`, and `[[ x =~ ( ]]` gives bash's two diagnostics. Reports are named `bash: -c`, the script path, `$0: eval` or the sourced file (`Error::syntax_report`); `if then`/`while do` with an empty condition are now errors at `then`/`do`. `bash`/`sh` children apply their redirects to their own errors (`bash -c 'if then fi' 2>/dev/null` printed the error). `time` honors `TIMEFORMAT` (`%[p][l]R`, `%%`; CPU fields `unavailable`). `[[ ! a || b ]]` negates only `a` (it negated the whole list), and `$LINENO` inside `[[ ]]`/`(( ))` keeps the enclosing list's line instead of 1. See limitations "`set -x`" and "Diagnostic prefix". bash-oracle strict 94 to 99/106.
 * **Fix**: stderr goes where bash sends it. A command's own failure honors its redirects: `nocmd 2>/dev/null` and `./missing 2>/dev/null` are silent, `return 2>&1` at top level reports on stdout, and so do `source`/`.`/`getopts`/`builtin` usage errors. Stderr written inside `$(...)` is no longer dropped (`x=$(nocmd)` reports `nocmd: command not found`, `$(< missing)` reports the file): it is queued on the interpreter and emitted ahead of the expanding command's own stderr, outside that command's redirects (words are expanded first) and inside a compound command's. `eval` text counts `$LINENO` and diagnostics from the eval's own line (it restarted at 1). `exit` uses `$?` with no argument (it exited 0), reports `numeric argument required` and exits 2 for a non-number (it exited 0), and `exit 1 2` reports `too many arguments` and drops the rest of the line. `/proc` refuses new entries like procfs: `echo y > /proc/naopode` fails with `No such file or directory` (it created the file); `mkdir`/`touch` print the strerror text instead of `io error: ...`. See [VFS](foundations/vfs.md) and limitations "Stderr routing". bash-oracle match 98 to 100/106, strict 89 to 93/106.
 * **Fix**: `${v@a}` prints every attribute letter `declare -p` shows, in bash's order (`a`/`A`, `i`, `n`, `r`, `x`, `l`, `u`), follows namerefs, takes the array from a subscript, and repeats per element for `${arr[@]@a}`. It only knew `r` and `x`, so `declare -i n; ${n@a}` was empty.
 * **Fix**: `${#v}` counts bytes when the shell's locale is C/POSIX (`LC_ALL`, then `LC_CTYPE`, then `LANG`, first non-empty), like bash; `LC_ALL=C; s=ação; ${#s}` is 6. With no locale variable set bashkit stays UTF-8, where bash would fall back to C. `${#s}` inside a `${x:-...}` operand counted bytes in every locale and now counts characters. Other operators (`${s:0:2}`, case changes, globs) stay character-based under C (limitations, "Locale").
diff --git a/knowledge/operations/limitations.md b/knowledge/operations/limitations.md
index e61a161ae..1d0bc1195 100644
--- a/knowledge/operations/limitations.md
+++ b/knowledge/operations/limitations.md
@@ -103,7 +103,7 @@ Target: IEEE 1003.1-2024 Shell Command Language.
 |---------|------------|----------------|
 | Prefix env assignments | `VAR=val cmd` temporarily sets env for cmd | Array prefix assignments not in env |
 | `return` | Basic usage | Return value propagation |
-| `time` | Reserved-word pipelines; `-p`, `--`, GNU `-f/-o/-a/-v`; elapsed time, exit status, and Bashkit counters | Host user/system CPU, RSS, and other process metrics are reported as `unavailable`, never fabricated |
+| `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`, `-n`, `-e`, `-x`, `-u`, `-f`, `-o option`, script files, stdin, `--version`, `--help` | Login shell |
 | 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) |
@@ -111,8 +111,9 @@ Target: IEEE 1003.1-2024 Shell Command Language.
 | 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 |
 | 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); `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 `?` still work on characters, not bytes: 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 | `(( ))`, `[[ ]]`, `{ }` and `( )` carry no span, so an error raised by the construct itself (not a command inside it) reports a stale line (line 1 at the top level); 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-error wording differs from bash; 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: `(( ))`/`[[ ]]` 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 |
 | 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 | stdout and stderr of one command are separate values, so `{ a; b; } 2>&1` puts the merged stderr after the group's stdout instead of in write order; `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; `export`/`declare` do not trace their own assignment (`+ Q=1`); 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); `declare -a a=(1 2)` traces as `declare -a a` without bash's `a=('1' '2')` line; a `<(...)` body is not traced |
 | 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}` |
 
 ## Builtins
diff --git a/scripts/bash-oracle/floor.txt b/scripts/bash-oracle/floor.txt
index 87bb23b0b..3e222a75b 100644
--- a/scripts/bash-oracle/floor.txt
+++ b/scripts/bash-oracle/floor.txt
@@ -1 +1 @@
-101 94
+101 99