From 4073d1576876107e0750a51682a64319cf0c08c2 Mon Sep 17 00:00:00 2001
From: Gabriel Schneider <gbrls@0x4200.cafe>
Date: Mon, 28 Sep 2026 22:25:46 -0300
Subject: Kill stops a command pane's whole line again, now it runs with job
 control

With the line run under job control (the change before), the job running
has a group of its own, and Kill's SIGTERM to the tty's foreground group
stopped only that job: of `sleep 30; touch x` the touch still ran. For a
command pane the hosts now signal the shell's group as well, so the whole
line stops, as it did; a line typed at a prompt still loses only its
foreground job. The test forks a real pty for both halves: a background job
outliving its command and the pty's hangup, and a killed line not running on.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 src/host_io.zig | 51 +++++++++++++++++++++++++++++++++++++++++++++------
 1 file changed, 45 insertions(+), 6 deletions(-)

(limited to 'src/host_io.zig')

diff --git a/src/host_io.zig b/src/host_io.zig
index 53e1628d..df78f73c 100644
--- a/src/host_io.zig
+++ b/src/host_io.zig
@@ -1670,7 +1670,11 @@ fn reapShell(pid: libc.pid_t, grace_ms: u32) void {
     while (libc.waitpid(pid, null, 0) < 0 and libc.errno(-1) == .INTR) {}
 }
 
-pub fn signalTty(shell_pid: libc.pid_t, master_fd: c_int, which: pardes.PtySignal) void {
+/// The tty's foreground job is signalled. A command pane's shell (`command`)
+/// is its command too: its line runs with job control on, so the job
+/// running is in a group of its own, and the shell's group goes as well, or
+/// the rest of the line would run on after the job it was on.
+pub fn signalTty(shell_pid: libc.pid_t, master_fd: c_int, which: pardes.PtySignal, command: bool) void {
     const sig = switch (which) {
         .int => libc.SIG.INT,
         .term => libc.SIG.TERM,
@@ -1679,11 +1683,9 @@ pub fn signalTty(shell_pid: libc.pid_t, master_fd: c_int, which: pardes.PtySigna
         .kill => libc.SIG.KILL,
     };
     const fg = tcgetpgrp(master_fd);
-    if (fg > 0) {
-        _ = libc.kill(-fg, sig);
-        return;
-    }
-    if (shell_pid > 0) _ = libc.kill(shell_pid, sig);
+    if (fg > 0) _ = libc.kill(-fg, sig);
+    if (command and shell_pid > 0 and fg != shell_pid) _ = libc.kill(-shell_pid, sig);
+    if (fg <= 0 and !command and shell_pid > 0) _ = libc.kill(shell_pid, sig);
 }
 
 /// Kill: SIGTERM to the job in the tty's foreground, never to the shell.
@@ -2074,6 +2076,43 @@ test "a command's exit is its process's, told by its watcher, whether or not its
     }
 }
 
+test "a command's background job outlives it and its pty, and Kill stops its whole line" {
+    if (comptime !tty_probe_platform) return error.SkipZigTest;
+    if (!haveFile("/bin/sh")) return error.SkipZigTest;
+    const core = try pardes.Pardes.init(std.testing.allocator, .{ .tty_only = true });
+    defer core.deinit();
+    while (core.nextEffect()) |_| {}
+    const rcs: Shell.PromptFiles = .{};
+    var tmp = std.testing.tmpDir(.{});
+    defer tmp.cleanup();
+    var dir_buf: [4096]u8 = undefined;
+    const dir = dir_buf[0..try tmp.dir.realPath(std.testing.io, &dir_buf)];
+    const Case = struct { line: []const u8, kill: bool, made: bool };
+    for ([_]Case{
+        // The shell leads the pty's session; its exit hangs up only the
+        // foreground group, which the job, in a group of its own, is not.
+        .{ .line = "(sleep 0.4; touch left) & exit 0", .kill = false, .made = true },
+        // The job running is in its own group; the shell goes too.
+        .{ .line = "sleep 0.4; touch killed", .kill = true, .made = false },
+    }) |c| {
+        const id = core.freeSlot().?;
+        _ = try core.newCommand(id, dir, c.line);
+        while (core.nextEffect()) |_| {}
+        const child = try forkShell(core, id, &rcs, "/bin/sh", dir, 24, 80, null);
+        if (c.kill) {
+            sleepMs(150);
+            signalTty(child.pid, child.file.handle, .term, true);
+        }
+        _ = exitStatus(child.pid, 2000);
+        _ = libc.close(child.file.handle); // the pane closes: the pty hangs up
+        sleepMs(800);
+        const name = if (c.kill) "killed" else "left";
+        const made = if (tmp.dir.statFile(std.testing.io, name, .{})) |_| true else |_| false;
+        try std.testing.expectEqual(c.made, made);
+        try core.removePane(id, null);
+    }
+}
+
 test "a retired shell that ignores the hangup is killed and reaped, not left a zombie" {
     const pid = libc.fork();
     if (pid == 0) {
-- 
cgit v1.3