Let a finished background session's jobs start before hanging it up

The shell passes its SIGHUP on to every job, and nohup ignores SIGHUP only
once it runs. A background session whose last command was 'nohup server &'
was hung up the moment its end marker arrived, so the SIGHUP reached the job
while it was still being forked and killed it. hang_up now waits 200 ms
first when the shell has jobs (stop::let_jobs_start), so nohup and disowned
jobs survive; plain jobs still die with the shell. kill/drop are unchanged.

Author: Parth Sharma

crates/terminal/src/lib.rs

@@ -305,7 +305,8 @@ impl Session {
 
     /// Stops the shell and the command it is running. Background jobs get
     /// the shell's SIGHUP, as when a terminal window closes, so jobs started
-    /// with `nohup` (e.g. a server) keep running.
+    /// with `nohup` (e.g. a server) keep running, including one started just
+    /// before the hang-up.
     pub(crate) fn hang_up(&mut self) {
         self.end_shell(Ending::Foreground);
     }
@@ -315,12 +316,13 @@ impl Session {
             if let Some(pid) = shell.child.process_id().and_then(|p| i32::try_from(p).ok()) {
                 let pid = Pid::from_raw(pid);
                 let foreground = shell.master.process_group_leader().map(Pid::from_raw);
+                let tty = shell.master.tty_name();
                 match ending {
-                    Ending::Session => {
-                        let tty = shell.master.tty_name();
-                        stop::stop_session(pid, tty.as_deref(), foreground);
+                    Ending::Session => stop::stop_session(pid, tty.as_deref(), foreground),
+                    Ending::Foreground => {
+                        stop::stop_foreground(pid, foreground);
+                        stop::let_jobs_start(pid, tty.as_deref());
                     }
-                    Ending::Foreground => stop::stop_foreground(pid, foreground),
                 }
             }
             // SIGHUP, then SIGKILL, to the shell. Errors only mean it already

crates/terminal/src/stop.rs

@@ -16,6 +16,12 @@ use nix::unistd::Pid;
 const TERM_GRACE: Duration = Duration::from_secs(1);
 const TERM_POLL: Duration = Duration::from_millis(20);
 
+/// How long the shell's jobs get to start before it is hung up. The shell
+/// passes its SIGHUP on to every job, and `nohup` ignores SIGHUP only once it
+/// runs, so a job forked just before the hang-up (`nohup server &` as the
+/// last command) would die with the shell.
+const JOB_START_GRACE: Duration = Duration::from_millis(200);
+
 /// Sends SIGTERM to every process group in the shell's session, waits up to
 /// [`TERM_GRACE`] for them to exit, then sends SIGKILL to whatever is left,
 /// the shell included. `tty` is the shell's terminal; `foreground` is that
@@ -47,6 +53,13 @@ pub(crate) fn stop_foreground(shell: Pid, foreground: Option<Pid>) {
     signal_groups(&[group], Signal::SIGKILL);
 }
 
+/// Waits [`JOB_START_GRACE`] if the shell has jobs, before it is hung up.
+pub(crate) fn let_jobs_start(shell: Pid, tty: Option<&Path>) {
+    if session_groups(shell, tty).iter().any(|&group| group != shell) {
+        std::thread::sleep(JOB_START_GRACE);
+    }
+}
+
 /// Sends SIGTERM to `groups` and waits up to [`TERM_GRACE`] for all of them
 /// but the shell's own to exit (an interactive shell ignores SIGTERM).
 fn terminate(groups: &[Pid], shell: Pid) {

docs/HOW-IT-WORKS.md

@@ -41,7 +41,7 @@ A command is not typed into the shell. It is written to a script file, and the s
 
 The end marker carries the exit status and the working directory, and because the command itself is sourced from a file, quotes, heredocs and commands that read stdin cannot swallow the marker. Working directory, environment and background jobs carry from one turn to the next, like a person's terminal.
 
-A command that has not finished after `exec_default_yield_ms` (10 seconds by default, `runtime.timeout` in agent.yaml) is left running in the background: the model gets the output so far and a session id, and can wait for more, send input or interrupt it with `write_stdin`. Up to `MAX_SESSIONS` shells exist at once. With `--linger` the shells stay open after the run, so a server the agent started keeps serving whoever needs it next. Otherwise, when the run ends, times out or is cancelled (an IPC `abort`, `kill`, closed stdin, or SIGTERM/SIGINT to `gitagent --ipc`), every process group in each shell's session gets SIGTERM and then, after at most a second, SIGKILL, so background jobs and the running command stop with the shell. A background session whose command finished only hangs up its shell, so a server it started with `nohup` keeps running.
+A command that has not finished after `exec_default_yield_ms` (10 seconds by default, `runtime.timeout` in agent.yaml) is left running in the background: the model gets the output so far and a session id, and can wait for more, send input or interrupt it with `write_stdin`. Up to `MAX_SESSIONS` shells exist at once. With `--linger` the shells stay open after the run, so a server the agent started keeps serving whoever needs it next. Otherwise, when the run ends, times out or is cancelled (an IPC `abort`, `kill`, closed stdin, or SIGTERM/SIGINT to `gitagent --ipc`), every process group in each shell's session gets SIGTERM and then, after at most a second, SIGKILL, so background jobs and the running command stop with the shell. A background session whose command finished only hangs up its shell, so a server it started with `nohup` keeps running. If that shell has jobs, the hang-up waits 0.2 s first: the shell passes its SIGHUP on to every job, and `nohup` only ignores it once it runs, so `nohup server &` as the last command would otherwise die with the shell.
 
 ## 4. The output shaper