fix(parser): handle heredoc pipe ordering and edge cases

- Lexer saves rest-of-line after heredoc delimiter and re-injects it via
  a VecDeque buffer, so `cat <<EOF | sort` correctly pipes heredoc content
- Pipe continuation (`cat <<EOF |\nsort`) also works via the same mechanism
- Quote-aware rest-of-line scanning handles `cat <<EOF; echo "two\nthree"`
  where double-quoted strings span physical lines
- read_continuation_into concatenates adjacent quoted/unquoted segments
  after single-quoted strings, enabling partial-quote delimiters like
  `<<'EOF'"2"` -> delimiter `EOF2`
- Multiple heredocs on one line work naturally via repeated rest-of-line
  save/reinject (e.g., `while cat <<E1 && cat <<E2; do ... done`)
- While/until condition stdout is now captured and emitted, fixing
  `while cat <<EOF; do ... done` producing no condition output

Enables all 6 previously-skipped heredoc-edge spec tests.

Closes #359

Author: claude

crates/bashkit/src/interpreter/mod.rs

@@ -1420,9 +1420,18 @@ impl Interpreter {
             self.counters.tick_loop(&self.limits)?;
 
             // Check condition (no errexit - conditions are expected to fail)
+            let emit_before_cond = self.output_emit_count;
             let condition_result = self
                 .execute_condition_sequence(&while_cmd.condition)
                 .await?;
+            // Condition commands produce visible output (e.g., `while cat <<EOF; do ... done`)
+            self.maybe_emit_output(
+                &condition_result.stdout,
+                &condition_result.stderr,
+                emit_before_cond,
+            );
+            stdout.push_str(&condition_result.stdout);
+            stderr.push_str(&condition_result.stderr);
             if condition_result.exit_code != 0 {
                 break;
             }
@@ -1505,9 +1514,18 @@ impl Interpreter {
             self.counters.tick_loop(&self.limits)?;
 
             // Check condition (no errexit - conditions are expected to fail)
+            let emit_before_cond = self.output_emit_count;
             let condition_result = self
                 .execute_condition_sequence(&until_cmd.condition)
                 .await?;
+            // Condition commands produce visible output
+            self.maybe_emit_output(
+                &condition_result.stdout,
+                &condition_result.stderr,
+                emit_before_cond,
+            );
+            stdout.push_str(&condition_result.stdout);
+            stderr.push_str(&condition_result.stderr);
             if condition_result.exit_code == 0 {
                 break;
             }

crates/bashkit/src/parser/lexer.rs

@@ -2,6 +2,8 @@
 //!
 //! Tokenizes input into a stream of tokens with source position tracking.
 
+use std::collections::VecDeque;
+
 use super::span::{Position, Span};
 use super::tokens::Token;
 
@@ -19,6 +21,9 @@ pub struct Lexer<'a> {
     /// Current position in the input
     position: Position,
     chars: std::iter::Peekable<std::str::Chars<'a>>,
+    /// Buffer for re-injected characters (e.g., rest-of-line after heredoc delimiter).
+    /// Consumed before `chars`.
+    reinject_buf: VecDeque<char>,
 }
 
 impl<'a> Lexer<'a> {
@@ -28,6 +33,7 @@ impl<'a> Lexer<'a> {
             input,
             position: Position::new(),
             chars: input.chars().peekable(),
+            reinject_buf: VecDeque::new(),
         }
     }
 
@@ -43,11 +49,19 @@ impl<'a> Lexer<'a> {
     }
 
     fn peek_char(&mut self) -> Option<char> {
-        self.chars.peek().copied()
+        if let Some(&ch) = self.reinject_buf.front() {
+            Some(ch)
+        } else {
+            self.chars.peek().copied()
+        }
     }
 
     fn advance(&mut self) -> Option<char> {
-        let ch = self.chars.next();
+        let ch = if !self.reinject_buf.is_empty() {
+            self.reinject_buf.pop_front()
+        } else {
+            self.chars.next()
+        };
         if let Some(c) = ch {
             self.position.advance(c);
         }
@@ -704,10 +718,67 @@ impl<'a> Lexer<'a> {
             self.advance();
         }
 
+        // If next char is another quote or word char, concatenate (e.g., 'EOF'"2" -> EOF2).
+        // Any quoting makes the whole token literal.
+        self.read_continuation_into(&mut content);
+
         // Single-quoted strings are literal - no variable expansion
         Some(Token::LiteralWord(content))
     }
 
+    /// After a closing quote, read any adjacent quoted or unquoted word chars
+    /// into `content`.  Handles concatenation like `'foo'"bar"baz` -> `foobarbaz`.
+    fn read_continuation_into(&mut self, content: &mut String) {
+        loop {
+            match self.peek_char() {
+                Some('\'') => {
+                    self.advance(); // opening '
+                    while let Some(ch) = self.peek_char() {
+                        if ch == '\'' {
+                            self.advance(); // closing '
+                            break;
+                        }
+                        content.push(ch);
+                        self.advance();
+                    }
+                }
+                Some('"') => {
+                    self.advance(); // opening "
+                    while let Some(ch) = self.peek_char() {
+                        if ch == '"' {
+                            self.advance(); // closing "
+                            break;
+                        }
+                        if ch == '\\' {
+                            self.advance();
+                            if let Some(next) = self.peek_char() {
+                                match next {
+                                    '"' | '\\' | '$' | '`' => {
+                                        content.push(next);
+                                        self.advance();
+                                    }
+                                    _ => {
+                                        content.push('\\');
+                                        content.push(next);
+                                        self.advance();
+                                    }
+                                }
+                                continue;
+                            }
+                        }
+                        content.push(ch);
+                        self.advance();
+                    }
+                }
+                Some(ch) if self.is_word_char(ch) => {
+                    content.push(ch);
+                    self.advance();
+                }
+                _ => break,
+            }
+        }
+    }
+
     /// Read ANSI-C quoted content ($'...').
     /// Opening $' already consumed. Returns the resolved string.
     fn read_dollar_single_quoted_content(&mut self) -> String {
@@ -1208,12 +1279,34 @@ impl<'a> Lexer<'a> {
         let mut content = String::new();
         let mut current_line = String::new();
 
-        // Skip to end of current line first (after the delimiter on command line)
+        // Save rest of current line (after the delimiter token on the command line).
+        // For `cat <<EOF | sort`, this captures ` | sort` so the parser can
+        // tokenize the pipe and subsequent command after the heredoc body.
+        //
+        // Quoted strings may span multiple lines (e.g., `cat <<EOF; echo "two\nthree"`),
+        // so we track quoting state and continue across newlines until quotes close.
+        let mut rest_of_line = String::new();
+        let mut in_double_quote = false;
+        let mut in_single_quote = false;
         while let Some(ch) = self.peek_char() {
             self.advance();
-            if ch == '\n' {
+            if ch == '\n' && !in_double_quote && !in_single_quote {
                 break;
             }
+            if ch == '"' && !in_single_quote {
+                in_double_quote = !in_double_quote;
+            } else if ch == '\'' && !in_double_quote {
+                in_single_quote = !in_single_quote;
+            } else if ch == '\\' && in_double_quote {
+                // Escaped char inside double quotes — skip the next char too
+                rest_of_line.push(ch);
+                if let Some(next) = self.peek_char() {
+                    rest_of_line.push(next);
+                    self.advance();
+                }
+                continue;
+            }
+            rest_of_line.push(ch);
         }
 
         // Read lines until we find the delimiter
@@ -1246,6 +1339,15 @@ impl<'a> Lexer<'a> {
             }
         }
 
+        // Re-inject saved rest-of-line so subsequent tokens (pipes, commands, etc.)
+        // are visible to the parser. Add a newline so the tokenizer sees the line break.
+        if !rest_of_line.is_empty() {
+            for ch in rest_of_line.chars() {
+                self.reinject_buf.push_back(ch);
+            }
+            self.reinject_buf.push_back('\n');
+        }
+
         content
     }
 }

crates/bashkit/src/parser/mod.rs

@@ -466,7 +466,9 @@ impl<'a> Parser<'a> {
                         kind,
                         target,
                     });
-                    break; // heredoc consumes rest of input line
+                    // Rest-of-line tokens re-injected by lexer; break so callers
+                    // can see pipes/semicolons.
+                    break;
                 }
                 _ => break,
             }
@@ -1810,8 +1812,10 @@ impl<'a> Parser<'a> {
                         target,
                     });
 
-                    // Heredoc body consumed subsequent lines from input.
-                    // Stop parsing this command - next tokens belong to new commands.
+                    // Heredoc body consumed subsequent lines. Break out of
+                    // parse_simple_command so pipeline/list parsers see any
+                    // rest-of-line tokens (|, ;, &&) that were re-injected
+                    // by the lexer.
                     break;
                 }
                 Some(tokens::Token::ProcessSubIn) | Some(tokens::Token::ProcessSubOut) => {
@@ -2740,4 +2744,35 @@ mod tests {
 
         assert!(matches!(&script.commands[0], Command::List(_)));
     }
+
+    #[test]
+    fn test_heredoc_pipe() {
+        let parser = Parser::new("cat <<EOF | sort\nc\na\nb\nEOF\n");
+        let script = parser.parse().unwrap();
+        assert!(
+            matches!(&script.commands[0], Command::Pipeline(_)),
+            "heredoc with pipe should parse as Pipeline"
+        );
+    }
+
+    #[test]
+    fn test_heredoc_multiple_on_line() {
+        let input = "while cat <<E1 && cat <<E2; do cat <<E3; break; done\n1\nE1\n2\nE2\n3\nE3\n";
+        let parser = Parser::new(input);
+        let script = parser.parse().unwrap();
+        assert_eq!(script.commands.len(), 1);
+        if let Command::Compound(comp, _) = &script.commands[0] {
+            if let CompoundCommand::While(w) = comp {
+                assert!(
+                    !w.condition.is_empty(),
+                    "while condition should be non-empty"
+                );
+                assert!(!w.body.is_empty(), "while body should be non-empty");
+            } else {
+                panic!("expected While compound command");
+            }
+        } else {
+            panic!("expected Compound command");
+        }
+    }
 }

crates/bashkit/tests/spec_cases/bash/heredoc-edge.test.sh

@@ -28,7 +28,6 @@ $var $(echo nope) $((1+2))
 
 ### heredoc_partial_quote_delimiter
 # Partial quote in delimiter still prevents expansion
-### skip: TODO partial quoting in heredoc delimiter not implemented
 cat <<'EOF'"2"
 one
 two
@@ -40,7 +39,6 @@ two
 
 ### heredoc_pipe_first_line
 # Here doc with pipe on first line
-### skip: TODO heredoc piped to sort - pipe ordering issue
 cat <<EOF | sort
 c
 a
@@ -54,7 +52,6 @@ c
 
 ### heredoc_pipe_last_line
 # Here doc with pipe continued on last line
-### skip: TODO heredoc pipe continuation - pipe ordering issue
 cat <<EOF |
 c
 a
@@ -94,7 +91,6 @@ X 3
 
 ### heredoc_in_while_condition
 # Here doc in while condition and body
-### skip: TODO multiple heredocs in while condition not parsed
 while cat <<E1 && cat <<E2; do cat <<E3; break; done
 1
 E1
@@ -110,7 +106,6 @@ E3
 
 ### heredoc_multiline_condition
 # Here doc in while condition on multiple lines
-### skip: TODO multiple heredocs in while condition not parsed
 while cat <<E1 && cat <<E2
 1
 E1
@@ -130,7 +125,6 @@ done
 
 ### heredoc_with_multiline_dquote
 # Here doc with multiline double quoted string
-### skip: TODO heredoc followed by multiline dquote on same line not parsed correctly
 cat <<EOF; echo "two
 three"
 one