Merge fix/devstdout: backlog item (sub-agent, worktree)

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: olwang

crates/rsscript/src/cli/dev.rs

@@ -7,13 +7,14 @@ use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
 
 use rsscript::{
     EvalError, EvalOutput, NativeValue, eval_package_main_with_args_and_native_bindings,
-    format_diagnostics_human, format_diagnostics_json, load_package_native_bindings,
-    reg_vm_eval_source_main_with_args,
+    eval_package_main_with_args_and_native_bindings_streaming_stdout,
+    eval_source_main_with_args_streaming_stdout, format_diagnostics_human, format_diagnostics_json,
+    load_package_native_bindings, reg_vm_eval_source_main_with_args,
 };
 
 use super::check::run_check;
 use super::lint::run_lint;
-use super::run_cmd::run_generated_rust;
+use super::run_cmd::{run_generated_rust, run_generated_rust_streaming};
 use super::{is_package_directory, print_usage};
 
 /// Action `rss dev` re-runs on every change. The default is the pure frontend
@@ -175,6 +176,11 @@ fn run_once(options: &DevOptions<'_>, path: &str) -> ExitCode {
         // reg-VM interpreter tier (no rustc cost); `--release` switches to the
         // Rust-lowering AOT tier. Both observe identical semantics + diagnostics
         // (the VM↔compiled parity invariant), so the fast tier is trustworthy.
+        // Stream the compiled program's stdio live in human mode; JSON mode keeps
+        // the captured path so its structured diagnostics stay intact.
+        DevAction::Run if options.release && !options.json => {
+            run_generated_rust_streaming(&run_args(options, path))
+        }
         DevAction::Run if options.release => run_generated_rust(&run_args(options, path)),
         DevAction::Run => run_via_vm(options, path),
     };
@@ -195,39 +201,67 @@ fn run_once(options: &DevOptions<'_>, path: &str) -> ExitCode {
 /// runs through the package VM with its native host bindings loaded; a single
 /// file runs through the source VM, mirroring `rss eval`.
 fn run_via_vm(options: &DevOptions<'_>, path: &str) -> ExitCode {
+    // Stream program stdout live in human mode so a slow/looping run shows output
+    // as it happens instead of buffering until exit. JSON mode keeps capturing so
+    // the diagnostics JSON is the only thing on stdout.
+    let stream = !options.json;
     let result = if is_package_directory(path) {
-        run_package_via_vm(path)
+        run_package_via_vm(path, stream)
     } else {
         match fs::read_to_string(path) {
             Ok(source) => {
-                reg_vm_eval_source_main_with_args(path, &source, std::iter::empty::<&str>())
+                if stream {
+                    eval_source_main_with_args_streaming_stdout(
+                        path,
+                        &source,
+                        std::iter::empty::<&str>(),
+                    )
+                } else {
+                    reg_vm_eval_source_main_with_args(path, &source, std::iter::empty::<&str>())
+                }
             }
             Err(error) => {
                 eprintln!("failed to read {path}: {error}");
                 return ExitCode::from(2);
             }
         }
     };
-    finish_vm_run(options, result)
+    finish_vm_run(options, result, stream)
 }
 
-fn run_package_via_vm(path: &str) -> Result<EvalOutput, EvalError> {
+fn run_package_via_vm(path: &str, stream: bool) -> Result<EvalOutput, EvalError> {
     let package_dir = Path::new(path);
     let bindings = load_package_native_bindings(package_dir).map_err(EvalError::Runtime)?;
-    eval_package_main_with_args_and_native_bindings(
-        package_dir,
-        std::iter::empty::<&str>(),
-        bindings,
-    )
+    if stream {
+        eval_package_main_with_args_and_native_bindings_streaming_stdout(
+            package_dir,
+            std::iter::empty::<&str>(),
+            bindings,
+        )
+    } else {
+        eval_package_main_with_args_and_native_bindings(
+            package_dir,
+            std::iter::empty::<&str>(),
+            bindings,
+        )
+    }
 }
 
 /// Render a VM run result the same way `rss eval` does: program stdout/stderr,
 /// then the `main` return value, with an `Err` return reported as a failed run
 /// (matching the AOT backend's exit behavior).
-fn finish_vm_run(options: &DevOptions<'_>, result: Result<EvalOutput, EvalError>) -> ExitCode {
+fn finish_vm_run(
+    options: &DevOptions<'_>,
+    result: Result<EvalOutput, EvalError>,
+    streamed: bool,
+) -> ExitCode {
     match result {
         Ok(output) => {
-            print!("{}", output.stdout);
+            // When the run streamed stdout live, the program output is already on
+            // the terminal — printing `output.stdout` again would duplicate it.
+            if !streamed {
+                print!("{}", output.stdout);
+            }
             eprint!("{}", output.stderr);
             if let Some(NativeValue::Variant { name, .. }) = &output.native_value
                 && name == "Err"

crates/rsscript/src/cli/run_cmd.rs

@@ -63,6 +63,18 @@ fn parse_run_args(args: &[String]) -> Result<RunOptions<'_>, String> {
     })
 }
 pub(crate) fn run_generated_rust(args: &[String]) -> ExitCode {
+    run_generated_rust_inner(args, false)
+}
+
+/// Like [`run_generated_rust`] but inherits the child's stdio so the compiled
+/// program's output streams live instead of being captured and printed at exit.
+/// Used by `rss dev --run --release` so a slow/looping run shows progress. `rss
+/// run` keeps capturing (so its runtime-diagnostic parsing is unchanged).
+pub(crate) fn run_generated_rust_streaming(args: &[String]) -> ExitCode {
+    run_generated_rust_inner(args, true)
+}
+
+fn run_generated_rust_inner(args: &[String], stream_stdio: bool) -> ExitCode {
     let options = match parse_run_args(args) {
         Ok(options) => options,
         Err(error) => {
@@ -133,6 +145,33 @@ pub(crate) fn run_generated_rust(args: &[String]) -> ExitCode {
     if let Ok(current_dir) = std::env::current_dir() {
         cargo.env("RSS_RUN_WORKSPACE_ROOT", current_dir);
     }
+    if stream_stdio {
+        // Inherit stdio so cargo's build progress and the program's stdout stream
+        // live to the terminal (no buffering until exit). The captured-output
+        // diagnostic post-processing is intentionally skipped here; it only runs
+        // for the captured `rss run` path.
+        let status = match cargo.status() {
+            Ok(status) => status,
+            Err(error) => {
+                eprintln!("failed to run cargo: {error}");
+                if cleanup_package_dir {
+                    cleanup_temp_dir(&package_dir);
+                }
+                return ExitCode::from(2);
+            }
+        };
+        if cleanup_package_dir {
+            cleanup_temp_dir(&package_dir);
+        }
+        return if status.success() {
+            ExitCode::SUCCESS
+        } else {
+            status
+                .code()
+                .map(|code| ExitCode::from(code as u8))
+                .unwrap_or_else(|| ExitCode::from(1))
+        };
+    }
     let output = match cargo.output() {
         Ok(output) => output,
         Err(error) => {

crates/rsscript/src/lib.rs

@@ -92,7 +92,9 @@ pub use reg_vm::{
     reg_vm_compile_source as vm_compile_source, reg_vm_compile_source,
     reg_vm_eval_package_main_with_args as eval_package_main_with_args,
     reg_vm_eval_package_main_with_args_and_native_bindings as eval_package_main_with_args_and_native_bindings,
+    reg_vm_eval_package_main_with_args_and_native_bindings_streaming_stdout as eval_package_main_with_args_and_native_bindings_streaming_stdout,
     reg_vm_eval_source_main as eval_source_main, reg_vm_eval_source_main_jit,
+    reg_vm_eval_source_main_with_args_streaming_stdout as eval_source_main_with_args_streaming_stdout,
     reg_vm_eval_source_main_with_args,
     reg_vm_eval_source_main_with_args as eval_source_main_with_args,
     reg_vm_eval_source_main_with_args as vm_eval_source_main_with_args,

crates/rsscript/src/reg_vm/mod.rs

@@ -1114,6 +1114,34 @@ pub fn reg_vm_eval_source_main_with_args_and_native_bindings(
         .eval_main_with_args_and_native_bindings(args, native_bindings)
 }
 
+/// Streaming-stdout source entry point for `rss dev --run`: evaluates `main` and
+/// writes `Log.write` output live (line-flushed) to the real process stdout as it
+/// runs. The captured stdout in the returned `EvalOutput` is unchanged, so it must
+/// not be re-printed by the caller. Other callers and the tests keep using the
+/// non-streaming `reg_vm_eval_source_main_with_args`, whose behavior is untouched.
+pub fn reg_vm_eval_source_main_with_args_streaming_stdout(
+    file: &str,
+    source: &str,
+    args: impl IntoIterator<Item = impl Into<String>>,
+) -> Result<EvalOutput, EvalError> {
+    reg_vm_compile_source(file, source)?
+        .eval_main_with_args_and_native_bindings_streaming_stdout(
+            args,
+            std::iter::empty::<(String, NativeInterpreterFn)>(),
+        )
+}
+
+/// Streaming-stdout package entry point for `rss dev --run`. See
+/// [`reg_vm_eval_source_main_with_args_streaming_stdout`].
+pub fn reg_vm_eval_package_main_with_args_and_native_bindings_streaming_stdout(
+    package_dir: &Path,
+    args: impl IntoIterator<Item = impl Into<String>>,
+    native_bindings: impl IntoIterator<Item = (impl Into<String>, NativeInterpreterFn)>,
+) -> Result<EvalOutput, EvalError> {
+    reg_vm_compile_package(package_dir)?
+        .eval_main_with_args_and_native_bindings_streaming_stdout(args, native_bindings)
+}
+
 pub fn reg_vm_eval_package_main_with_args(
     package_dir: &Path,
     args: impl IntoIterator<Item = impl Into<String>>,
@@ -1387,6 +1415,47 @@ impl RegVmExecutable {
         })
     }
 
+    /// Like [`Self::eval_main_with_args_and_native_bindings`] but streams program
+    /// stdout (`Log.write` output) live to the real process stdout, line-flushed,
+    /// as the program runs. Used ONLY by `rss dev --run` so a slow/looping program
+    /// shows output immediately instead of buffering until exit. The returned
+    /// `EvalOutput.stdout` is still the full captured buffer (identical to the
+    /// non-streaming call), so the program output has already been written to the
+    /// terminal — the caller must NOT print it a second time.
+    pub fn eval_main_with_args_and_native_bindings_streaming_stdout(
+        &self,
+        args: impl IntoIterator<Item = impl Into<String>>,
+        native_bindings: impl IntoIterator<Item = (impl Into<String>, NativeInterpreterFn)>,
+    ) -> Result<EvalOutput, EvalError> {
+        let mut vm = RegVm::new(
+            Rc::clone(&self.unit),
+            args.into_iter().map(Into::into).collect(),
+            native_bindings
+                .into_iter()
+                .map(|(key, function)| (key.into(), function))
+                .collect(),
+        );
+        vm.stream_stdout = true;
+        let result = vm.run_program("main");
+        // Flush any final line that lacks a trailing newline so no output is lost.
+        if vm.stream_flushed < vm.stdout.len() {
+            let mut out = std::io::stdout();
+            let _ = out.write_all(vm.stdout[vm.stream_flushed..].as_bytes());
+            let _ = out.flush();
+            vm.stream_flushed = vm.stdout.len();
+        }
+        let value = result?;
+        let display_value = value.display();
+        let native_value = value.native_value();
+        Ok(EvalOutput {
+            value: display_value.clone(),
+            display_value,
+            native_value,
+            stdout: vm.stdout,
+            stderr: vm.stderr,
+        })
+    }
+
     pub fn eval_main_with_args_and_native_bindings(
         &self,
         args: impl IntoIterator<Item = impl Into<String>>,
@@ -6056,6 +6125,15 @@ struct RegVm {
     args: Vec<String>,
     native_bindings: HashMap<String, NativeInterpreterFn>,
     stdout: String,
+    /// When set, complete lines appended to `stdout` are also written live to the
+    /// real process stdout (line-flushed). Used ONLY by `rss dev --run` so a slow
+    /// or looping program shows output as it runs instead of buffering until exit.
+    /// `stream_flushed` tracks how many bytes of `stdout` have been streamed so a
+    /// partial trailing line is not emitted twice. The captured `stdout` String is
+    /// built identically whether or not streaming is on, so every other caller
+    /// (and the parity/differential tests) is unaffected.
+    stream_stdout: bool,
+    stream_flushed: usize,
     stderr: String,
     stack: Vec<VmValue>,
     written: Vec<bool>,
@@ -6376,6 +6454,8 @@ impl RegVm {
             args,
             native_bindings,
             stdout: String::new(),
+            stream_stdout: false,
+            stream_flushed: 0,
             stderr: String::new(),
             stack: Vec::new(),
             written: Vec::new(),
@@ -6402,6 +6482,32 @@ impl RegVm {
         }
     }
 
+    /// Append program output to the captured `stdout` buffer, and — when live
+    /// streaming is enabled (`rss dev --run`) — flush newly completed lines to the
+    /// real process stdout immediately. The captured buffer is appended to exactly
+    /// the same way regardless, so callers that read `EvalOutput.stdout` see no
+    /// difference.
+    fn push_stdout(&mut self, text: &str) {
+        self.stdout.push_str(text);
+        if self.stream_stdout {
+            self.flush_stdout_stream();
+        }
+    }
+
+    /// Write every complete (newline-terminated) line appended since the last
+    /// flush to the real process stdout, then advance the streamed cursor. A
+    /// partial trailing line is left buffered until its newline arrives.
+    fn flush_stdout_stream(&mut self) {
+        if let Some(offset) = self.stdout[self.stream_flushed..].rfind('\n') {
+            let end = self.stream_flushed + offset + 1;
+            let chunk = &self.stdout[self.stream_flushed..end];
+            let mut out = std::io::stdout();
+            let _ = out.write_all(chunk.as_bytes());
+            let _ = out.flush();
+            self.stream_flushed = end;
+        }
+    }
+
     /// Whether `func` should run on the tier-0 JIT. Reads the analysis cached on
     /// the function (`(eligible, has_loop)`, computed once for the whole unit by
     /// [`compute_jit_eligibility`], which already accounts for cross-function
@@ -9227,8 +9333,7 @@ impl RegVm {
                 Ok(json_result(if sql.trim().is_empty() {
                     Err(db_error_value("SQL query is empty"))
                 } else {
-                    self.stdout
-                        .push_str(&format!("db query on {}: {sql}\n", conn.url));
+                    self.push_stdout(&format!("db query on {}: {sql}\n", conn.url));
                     conn.queries.push(sql);
                     self.set_reg(base + conn_reg, conn.to_value());
                     Ok(VmValue::Unit)
@@ -9803,8 +9908,9 @@ impl RegVm {
             }
             RegIntrinsic::ImageInspect => {
                 let image = expect_image_state(intrinsic_arg(&self.stack, base, args, 0)?)?;
-                self.stdout.push_str(&image.inspect_line());
-                self.stdout.push('\n');
+                let line = image.inspect_line();
+                self.push_stdout(&line);
+                self.push_stdout("\n");
                 Ok(VmValue::Unit)
             }
             RegIntrinsic::ImageLoad => {
@@ -9924,24 +10030,20 @@ impl RegVm {
                     expect_string_ref(intrinsic_arg(&self.stack, base, args, 0)?)?.to_string();
                 let message =
                     expect_string_ref(intrinsic_arg(&self.stack, base, args, 1)?)?.to_string();
-                self.stdout.push_str("trace ");
-                self.stdout.push_str(&event);
-                self.stdout.push_str(": ");
-                self.stdout.push_str(&message);
-                self.stdout.push('\n');
+                self.push_stdout(&format!("trace {event}: {message}\n"));
                 Ok(VmValue::Unit)
             }
             RegIntrinsic::LogWrite => {
                 let line =
                     expect_string_ref(intrinsic_arg(&self.stack, base, args, 0)?)?.to_string();
-                self.stdout.push_str(&line);
-                self.stdout.push('\n');
+                self.push_stdout(&line);
+                self.push_stdout("\n");
                 Ok(VmValue::Unit)
             }
             RegIntrinsic::LogWriteJson => {
                 let value = expect_json_ref(intrinsic_arg(&self.stack, base, args, 0)?)?;
-                self.stdout.push_str(&value.to_string());
-                self.stdout.push('\n');
+                self.push_stdout(&value.to_string());
+                self.push_stdout("\n");
                 Ok(VmValue::Unit)
             }
             RegIntrinsic::MapContainsKey | RegIntrinsic::MapFilter | RegIntrinsic::MapFold | RegIntrinsic::MapForEach | RegIntrinsic::MapGetOrDefault | RegIntrinsic::MapIsEmpty | RegIntrinsic::MapKeys | RegIntrinsic::MapLen | RegIntrinsic::MapMapValues | RegIntrinsic::MapMerge | RegIntrinsic::MapNew | RegIntrinsic::MapTryFold | RegIntrinsic::MapValues => self.exec_map_intrinsics(unit, intrinsic, args, base, next_base),