@@ -704,15 +704,39 @@ pub(crate) async fn run(cli: Cli) -> ! {
             let _ = stdout.flush().await;
         }
     });
-    // `session` drops its shells and MCP servers before returning.
-    let code = session(cli, out.clone()).await;
+    // `session` drops its shells and MCP servers before returning. A stop
+    // signal drops it too, so the commands the shells run do not outlive us.
+    let code = tokio::select! {
+        code = session(cli, out.clone()) => code,
+        signal = stop_signal() => 128 + signal,
+    };
     out.send(Value::Null);
     let _ = writer.await;
     // The stdin reader may still be waiting in a blocking read the runtime
     // would wait for (a client may keep its end open after `session_end`).
     std::process::exit(code)
 }
 
+/// Waits for SIGTERM or SIGINT and returns its number.
+async fn stop_signal() -> i32 {
+    use tokio::signal::unix::{signal, SignalKind};
+    let wait_for = |kind: SignalKind| async move {
+        match signal(kind) {
+            Ok(mut stream) => {
+                stream.recv().await;
+                kind.as_raw_value()
+            }
+            // No handler was installed, so the signal keeps its default
+            // action (ending the process) and this branch never fires.
+            Err(_) => std::future::pending().await,
+        }
+    };
+    tokio::select! {
+        number = wait_for(SignalKind::terminate()) => number,
+        number = wait_for(SignalKind::interrupt()) => number,
+    }
+}
+
 async fn session(cli: Cli, out: Out) -> i32 {
     let mut lines = BufReader::new(tokio::io::stdin()).lines();
     let fatal = |out: &Out, why: String| {
 
@@ -325,6 +325,63 @@ fn steering_and_abort() {
     assert!(is("system", "session_end")(rest.last().unwrap()));
 }
 
+fn process_exists(pid: &str) -> bool {
+    Command::new("kill")
+        .args(["-0", pid])
+        .stderr(Stdio::null())
+        .status()
+        .unwrap()
+        .success()
+}
+
+#[test]
+fn sigterm_stops_the_running_command() {
+    let tmp = tempfile::tempdir().unwrap();
+    let work = tmp.path().join("work");
+    std::fs::create_dir_all(&work).unwrap();
+    let model = script(
+        tmp.path(),
+        "s.yaml",
+        "- tool_calls: [{name: exec, arguments: {cmd: \"sh -c 'echo $$ > pid.txt; exec sleep 300'\", yield_ms: 60000}}]\n\
+         - text: \"unreachable\"\n",
+    );
+    let mut s = Session::start(tmp.path(), &tmp.path().join("out"));
+    s.send(json!({"type": "initialize", "protocol": 1, "options": {"model": model, "dir": work, "sessionId": "sig"}}));
+    s.until(is("system", "session_start"));
+    s.send(json!({"type": "user", "content": "sleep"}));
+    s.until(|m| m["type"] == "tool_use");
+    let pid_file = work.join("pid.txt");
+    let mut pid = String::new();
+    for _ in 0..100 {
+        pid = std::fs::read_to_string(&pid_file)
+            .unwrap_or_default()
+            .trim()
+            .to_string();
+        if !pid.is_empty() {
+            break;
+        }
+        std::thread::sleep(Duration::from_millis(50));
+    }
+    assert!(process_exists(&pid), "the command did not start: {pid:?}");
+
+    let gitagent = s.child.id().to_string();
+    assert!(Command::new("kill")
+        .args(["-TERM", &gitagent])
+        .status()
+        .unwrap()
+        .success());
+    let code = s.child.wait().unwrap().code();
+    assert_eq!(code, Some(143));
+    // The shell is gone at once; its orphaned command is reaped shortly after.
+    for _ in 0..100 {
+        if !process_exists(&pid) {
+            return;
+        }
+        std::thread::sleep(Duration::from_millis(50));
+    }
+    panic!("pid {pid} survived SIGTERM");
+}
+
 #[test]
 fn startup_problems_and_blocking_hooks() {
     let tmp = tempfile::tempdir().unwrap();
 
@@ -10,6 +10,7 @@ workspace = true
 
 [dependencies]
 anyhow.workspace = true
+nix = { version = "0.28", default-features = false, features = ["signal", "process"] }
 portable-pty = "0.9.0"
 tokio.workspace = true
 
 
@@ -80,7 +80,10 @@ impl OutputBuffer {
                 return None;
             };
             let line = String::from_utf8_lossy(&self.data[line_start..line_start + nl]);
-            let (code, cwd) = line.split_once(' ').unwrap_or((&line, ""));
+            // A terminal that still maps `\n` to `\r\n` (seen on macOS) ends
+            // the line with `\r`, which would otherwise end up in the cwd.
+            let line = line.trim_end_matches('\r');
+            let (code, cwd) = line.split_once(' ').unwrap_or((line, ""));
             let Ok(exit) = code.parse::<i32>() else {
                 // Not our marker (for example the text of the printf format).
                 from = line_start;
@@ -170,6 +173,17 @@ mod tests {
         assert_eq!(t.output, b"x\n__GA_END_2__ 0 /\n\n__GA_END_3__ %s %s\ny");
     }
 
+    #[test]
+    fn strips_carriage_return_from_the_marker_cwd() {
+        let mut b = OutputBuffer::new(1 << 20);
+        b.push(b"out\r\n__GA_END_4__ 0 /tmp/dir\r\nrest");
+        let (m, t) = b.take_marker(4).unwrap();
+        assert_eq!(m.exit, 0);
+        assert_eq!(m.cwd, "/tmp/dir");
+        assert_eq!(t.output, b"out\r");
+        assert_eq!(b.take_all().output, b"rest");
+    }
+
     #[test]
     fn partial_take_holds_back_a_split_marker() {
         let mut b = OutputBuffer::new(1 << 20);
 
@@ -9,6 +9,7 @@
 mod buffer;
 mod keys;
 mod manager;
+mod stop;
 
 pub use keys::decode_keys;
 pub use manager::{Terminal, MAIN_SESSION, MAX_SESSIONS};
@@ -18,6 +19,7 @@ use std::path::{Path, PathBuf};
 use std::time::{Duration, Instant};
 
 use anyhow::{bail, Context, Result};
+use nix::unistd::Pid;
 use portable_pty::{native_pty_system, Child, CommandBuilder, MasterPty, PtySize};
 use tokio::sync::mpsc;
 use tokio::time::timeout_at;
@@ -109,6 +111,14 @@ enum ReadEvent {
     Eof,
 }
 
+/// What ending a shell stops besides the shell.
+enum Ending {
+    /// Every process in the shell's session, background jobs included.
+    Session,
+    /// Only the command in the terminal's foreground.
+    Foreground,
+}
+
 struct Shell {
     master: Box<dyn MasterPty + Send>,
     writer: Box<dyn Write + Send>,
@@ -287,9 +297,34 @@ impl Session {
         }
     }
 
-    /// Stops the shell and everything started from it.
+    /// Stops the shell and everything started from it: the running command
+    /// and background jobs, which job control puts in groups of their own.
     pub fn kill(&mut self) {
+        self.end_shell(Ending::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.
+    pub(crate) fn hang_up(&mut self) {
+        self.end_shell(Ending::Foreground);
+    }
+
+    fn end_shell(&mut self, ending: Ending) {
         if let Some(mut shell) = self.shell.take() {
+            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);
+                match ending {
+                    Ending::Session => {
+                        let tty = shell.master.tty_name();
+                        stop::stop_session(pid, tty.as_deref(), foreground);
+                    }
+                    Ending::Foreground => stop::stop_foreground(pid, foreground),
+                }
+            }
+            // SIGHUP, then SIGKILL, to the shell. Errors only mean it already
+            // exited; `wait` then just reaps it.
             let _ = shell.child.kill();
             let _ = shell.child.wait();
         }
@@ -414,7 +449,7 @@ impl Session {
                 ]);
             }
         }
-        self.kill();
+        self.hang_up();
         Ok(vec![
             "The previous command did not stop on Ctrl-C, so its shell was killed.".into(),
         ])
 
@@ -84,8 +84,12 @@ impl Terminal {
         let mut session = Session::start(cfg).await?;
         let mut r = session.exec(cmd, yield_ms).await?;
         r.session = id;
+        // A finished session only hangs up, so a server it started with
+        // `nohup` keeps running for the rest of the run (and for `--linger`).
         if session.is_running() {
             self.sessions.insert(id, session);
+        } else {
+            session.hang_up();
         }
         Ok(r)
     }
@@ -103,7 +107,9 @@ impl Terminal {
         r.session = id;
         // A background session is done once its command finishes.
         if id != MAIN_SESSION && !session.is_running() {
-            self.sessions.remove(&id);
+            if let Some(mut done) = self.sessions.remove(&id) {
+                done.hang_up();
+            }
         }
         Ok(r)
     }
@@ -251,4 +257,34 @@ mod tests {
         t.kill_all();
         assert!(t.background_sessions().is_empty());
     }
+
+    #[tokio::test]
+    async fn a_finished_background_session_leaves_nohup_jobs_until_the_terminal_ends() {
+        use crate::tests::{parse_pid, process_exists, wait_until_gone};
+        let (_d, mut t) = start().await;
+        let r = t
+            .exec("nohup sleep 300 >/dev/null 2>&1 & echo $!", 5000, true)
+            .await
+            .unwrap();
+        assert!(r.finished);
+        assert!(t.background_sessions().is_empty());
+        let pid = parse_pid(&r);
+        tokio::time::sleep(Duration::from_millis(500)).await;
+        assert!(
+            process_exists(pid),
+            "the nohup job was stopped with its session"
+        );
+
+        let r = t.exec("sleep 300 & echo $!", 5000, false).await.unwrap();
+        let main_job = parse_pid(&r);
+        drop(t);
+        assert!(wait_until_gone(main_job).await, "pid {main_job} survived");
+        // The finished session's job is no longer the terminal's to stop.
+        assert!(process_exists(pid));
+        nix::sys::signal::kill(
+            nix::unistd::Pid::from_raw(pid),
+            nix::sys::signal::Signal::SIGKILL,
+        )
+        .expect("stopping the nohup job");
+    }
 }