A command line runs as its own command pane unless it is clicked at a shell's prompt

A middle click, an exec write or a tag word that no builtin knows was typed
into some terminal for the pane's directory, sharing whatever state that
shell was in and answering nothing, so a misspelling vanished into a shell.
Now only a line clicked at an interactive terminal's prompt is typed there.
From anywhere else it runs as a command pane: a terminal whose child is
$SHELL -c the line in the pane's directory, full emulation, which shows its
output and then exit N from the host's reaping of the child, and stays. A
finished command pane is the next command's for its directory, which runs
below what it showed after a '% line' line (acme appends to +Errors and never
clears it, util.c:213); a running one gets a second pane. Kill ends a command
pane's whole process group, the log records run and exit, exec reads back the
command pane's serial, and a line is at most 1 KB, read off the pane as the
host forks rather than carried in every spawn effect. ttyForDir's search for
a free shell is gone. The goldens of chordcut, cmdword and layout-open change
where a file's exec now opens a command pane, and ttytaken is rewritten to
exec from the terminal itself; docs/open-questions.md records the decision.

Co-Authored-By: Claude Opus 5.5 <[email protected]>

13 files changed, 333 insertions, 123 deletions

diff --git a/src/builtins.zig b/src/builtins.zig
index d06897ff..19d16e1e 100644
--- a/src/builtins.zig
+++ b/src/builtins.zig
@@ -419,6 +419,21 @@ pub const Kill = struct {
         var jobless = false;
         for (c.p.panes, 0..) |slot, id| {
             const pane = slot orelse continue;
+            // A command pane's child is the command: the whole of its
+            // process group goes, as acme's Kill ends the process.
+            if (pane.command) |line| if (!pane.command_done) {
+                const said = std.mem.trim(u8, line, " \t");
+                const first = said[0 .. std.mem.indexOfAny(u8, said, " \t") orelse said.len];
+                if (names.len > 0) {
+                    var words = std.mem.tokenizeAny(u8, names, " \t");
+                    while (words.next()) |w| {
+                        if (std.mem.eql(u8, w, first)) break;
+                    } else continue;
+                }
+                c.p.emit(.{ .signal_pty = .{ .pane = @intCast(id), .sig = .term } });
+                stopped = true;
+                continue;
+            };
             if (!panes.Terminal.commandRunning(pane)) continue;
             const sent = pane.sent_command.?;
             if (names.len > 0) {
diff --git a/src/config.zig b/src/config.zig
index 6d0cf0a6..1a505334 100644
--- a/src/config.zig
+++ b/src/config.zig
@@ -248,6 +248,7 @@ pub const pane_builtins_str = "Tty Collapse Del";
 pub const pdf_pane_builtins_str = "Tty PdfSections PdfTint Collapse Del";
 pub const file_pane_builtins_str = "Save Tty Collapse Del";
 pub const terminal_pane_builtins_str = "Tty Save Mode Filter Collapse Del";
+pub const command_pane_builtins_str = "Kill Save Collapse Del";
 
 // Each mode badge is one codepoint.
 pub const tag_normal = " ";
diff --git a/src/detached/server.zig b/src/detached/server.zig
index 61fbe111..86ba2206 100644
--- a/src/detached/server.zig
+++ b/src/detached/server.zig
@@ -679,9 +679,12 @@ pub const Session = struct {
     }
 
     fn paneEof(s: *Session, pane: u8) void {
+        // Reaped here, its status kept, it is no shell to retire.
+        const status = host_io.exitStatus(s.ptys[pane].pid, 100);
+        if (status != null) s.ptys[pane].pid = 0;
         s.closePty(pane);
         s.harvest();
-        s.core.update(.{ .eof = .{ .pane = pane } });
+        s.core.update(.{ .eof = .{ .pane = pane, .status = status } });
     }
 
     fn harvest(s: *Session) void {
diff --git a/src/exec.zig b/src/exec.zig
index 2faf84de..07d5e92f 100644
--- a/src/exec.zig
+++ b/src/exec.zig
@@ -30,7 +30,8 @@ const Pardes = pardes.Pardes;
 
 pub fn takesCommandLine(p: *const Pardes, id: usize) bool {
     const pane = p.panes[id] orelse return false;
-    if (!pane.isTerminal()) return false;
+    // A command pane's child is its command, never a shell to type at.
+    if (!pane.isTerminal() or pane.command != null) return false;
     // A mounted shell sits behind sudo's process supervisor. Its OSC 133
     // prompt marks identify input readiness; the launcher's executable is
     // not the shell executable used by the ordinary process heuristic.
@@ -368,26 +369,16 @@ pub fn replaceStillborn(p: *Pardes) void {
     if (was_active) p.active = new_id;
 }
 
-fn ttyForDir(p: *Pardes, dir: []const u8) ?usize {
-    for (p.panes, 0..) |slot, i| if (slot) |tt| {
-        if (!std.mem.eql(u8, tt.cwdSlice(), dir)) continue;
-        if (takesCommandLine(p, i)) return i;
-    };
-    const free = p.freeSlot() orelse return null;
-    const nt = p.newShell(free, dir) catch return null;
-    nt.greet = false;
-    const rc = if (p.ncol > 0) p.ncol - 1 else 0;
-    if (p.col_n[rc] > 0) {
-        const src = layout.splitParent(p, p.col_panes[rc][p.col_n[rc] - 1]);
-        const f = layout.findPane(p, src).?;
-        layout.splitBelow(p, src, nt);
-        layout.insert(p, f.col, f.idx + 1, free);
-    } else layout.insert(p, rc, p.col_n[rc], free);
-    return free;
-}
+/// The longest line a command pane runs.
+pub const command_max = 1024;
 
 const max_exec_depth = 8;
 
+/// A word no builtin knows (acme's exec.c run()). Clicked in an interactive
+/// terminal, it is typed into that shell, whose state the click can see;
+/// from anywhere else it runs as its own command pane, a terminal whose
+/// child is `$SHELL -c` the line, which shows its output and `exit N` when
+/// done, and which Kill signals. Answers the pane it went to.
 pub fn execute(p: *Pardes, id: usize, txt: []const u8) ?usize {
     const pane = p.panes[id] orelse return null;
     const cmd = commandText(txt);
@@ -397,16 +388,93 @@ pub fn execute(p: *Pardes, id: usize, txt: []const u8) ?usize {
     if (p.exec_depth >= max_exec_depth) return null;
     p.exec_depth += 1;
     defer p.exec_depth -= 1;
-    const dst = (if (takesCommandLine(p, id)) id else ttyForDir(p, Pardes.paneDir(pane))) orelse return null;
-    panes.Terminal.padOutputBelowEdits(p, dst);
-    panes.Terminal.noteCommand(p.panes[dst].?, cmd);
-    if (panes.Terminal.queuePendingCommand(p.panes[dst].?, cmd) catch |err| {
+    if (!takesCommandLine(p, id)) return runCommand(p, id, cmd);
+    panes.Terminal.padOutputBelowEdits(p, id);
+    panes.Terminal.noteCommand(pane, cmd);
+    if (panes.Terminal.queuePendingCommand(pane, cmd) catch |err| {
         p.reportError(id, "queue command", err);
-        return dst;
-    }) return dst;
-    p.emitWrite(dst, cmd);
-    p.emitWrite(dst, "\r");
-    return dst;
+        return id;
+    }) return id;
+    p.emitWrite(id, cmd);
+    p.emitWrite(id, "\r");
+    return id;
+}
+
+/// Runs `line` in a command pane for `from`'s directory: `from` itself if
+/// it is one whose command is done, else the directory's command pane that
+/// is done, else a new one below the last pane of the rightmost column.
+/// A pane reused keeps what it showed: the new command runs below a line
+/// naming it, as acme appends to +Errors and never clears it (util.c:213).
+fn runCommand(p: *Pardes, from: usize, line: []const u8) ?usize {
+    if (line.len > command_max) {
+        p.reportFailure(from, "exec: a command line is at most 1024 bytes");
+        return null;
+    }
+    const src = p.panes[from] orelse return null;
+    const dir = Pardes.paneDir(src);
+    const reuse: ?usize = if (src.command != null and src.command_done) from else for (p.panes, 0..) |slot, i| {
+        const other = slot orelse continue;
+        if (other.command != null and other.command_done and std.mem.eql(u8, other.cwdSlice(), dir)) break i;
+    } else null;
+    if (reuse) |id| {
+        const pane = p.panes[id].?;
+        const owned = p.gpa.dupe(u8, line) catch |err| {
+            p.reportError(from, "exec", err);
+            return null;
+        };
+        p.gpa.free(pane.command.?);
+        pane.command = owned;
+        pane.command_done = false;
+        pane.command_status = null;
+        pane.body.mode = .tty;
+        var buf: [command_max + 8]u8 = undefined;
+        const lead = if (panes.Terminal.gridCursor(pane).x != 0) "\r\n" else "";
+        panes.Terminal.feedOutput(p, pane, std.fmt.bufPrint(&buf, "{s}% {s}\r\n", .{ lead, line }) catch "%\r\n");
+        p.emit(.{ .spawn = .{ .pane = @intCast(id), .cwd = .from(pane.cwdSlice()) } });
+        noteRun(p, pane, "run", line);
+        return id;
+    }
+    const free = p.freeSlot() orelse {
+        p.reportFailure(from, "exec: no pane free for the command");
+        return null;
+    };
+    const pane = p.newCommand(free, dir, line) catch |err| {
+        p.reportError(from, "exec", err);
+        return null;
+    };
+    const rc = if (p.ncol > 0) p.ncol - 1 else 0;
+    if (p.col_n[rc] > 0) {
+        const parent = layout.splitParent(p, p.col_panes[rc][p.col_n[rc] - 1]);
+        const f = layout.findPane(p, parent).?;
+        layout.splitBelow(p, parent, pane);
+        layout.insert(p, f.col, f.idx + 1, free);
+    } else layout.insert(p, rc, p.col_n[rc], free);
+    noteRun(p, pane, "run", line);
+    return free;
+}
+
+/// `run <serial> <word>` or `exit <serial> <N|?>` in the log.
+fn noteRun(p: *Pardes, pane: *Pane, what: []const u8, said: []const u8) void {
+    var buf: [96]u8 = undefined;
+    const word = std.mem.trim(u8, said, " \t");
+    const first = word[0 .. std.mem.indexOfAny(u8, word, " \t") orelse word.len];
+    pardes.ctlfs.events.notePath(p, what, std.fmt.bufPrint(&buf, "{d} {s}", .{ pane.serial, first[0..@min(first.len, 64)] }) catch return);
+}
+
+/// A command pane's child is gone: the pane stays, showing what it said
+/// and how it ended, and is the next command's for its directory.
+pub fn commandDone(p: *Pardes, id: usize, status: ?u8) void {
+    const pane = p.panes[id] orelse return;
+    pane.command_done = true;
+    pane.command_status = status;
+    pane.body.mode = .normal;
+    var buf: [16]u8 = undefined;
+    const code = if (status) |n| std.fmt.bufPrint(&buf, "{d}", .{n}) catch "?" else "?";
+    var said: [32]u8 = undefined;
+    const lead = if (panes.Terminal.gridCursor(pane).x != 0) "\r\n" else "";
+    panes.Terminal.feedOutput(p, pane, std.fmt.bufPrint(&said, "{s}exit {s}\r\n", .{ lead, code }) catch "exit ?\r\n");
+    noteRun(p, pane, "exit", code);
+    p.needs_frame = true;
 }
 
 /// Trim and unwrap clickable command-word notation once for every command
diff --git a/src/fs-help.txt b/src/fs-help.txt
index 7e869f9e..0e87f40e 100644
--- a/src/fs-help.txt
+++ b/src/fs-help.txt
@@ -39,7 +39,7 @@ Pitfalls, one each:
   data: > replaces the addr range, : > deletes it, a 2nd > inserts (addr moved); body: > empties all.
   tag reads the path, then its own text; writes append; truncating clears it, default words too.
   A terminal's body is a history snapshot frozen per open; pty/data is the live stream.
-  exec: a word no builtin knows is typed into a terminal in the pane's directory, and not an error.
+  exec: a non-builtin line runs as a command pane ($SHELL -c; exit N shown, logged), a shell's typed in.
   Through a mount a malformed write is EINVAL, a well-formed one that fails EIO: log's err says why.
   lock/unlock on a pane's ctl need a held fd (exec 3>ctl); a lock someone holds fails: retry.
   Closing a column's last pane leaves a +New in its place; Delcol closes the column.
diff --git a/src/gui/gui.zig b/src/gui/gui.zig
index 9ada305b..bfa83175 100644
--- a/src/gui/gui.zig
+++ b/src/gui/gui.zig
@@ -3878,13 +3878,19 @@ const Shell = struct {
             },
             .eof => |e| {
                 if (s.gens[e.pane] == e.gen) {
+                    // Reaped here, its status kept, it is no shell to retire.
+                    const status = if (s.ptys[e.pane]) |*pt| status: {
+                        const got = host_io.exitStatus(pt.pid, 100);
+                        if (got != null) pt.pid = 0;
+                        break :status got;
+                    } else null;
                     s.closePty(e.pane);
                     if (e.failure) |err| {
                         if (s.core.panes[e.pane]) |pane| {
                             pane.body.mode = .normal;
                             s.core.reportError(e.pane, "terminal reader", err);
                         }
-                    } else s.core.update(.{ .eof = .{ .pane = e.pane } });
+                    } else s.core.update(.{ .eof = .{ .pane = e.pane, .status = status } });
                 }
                 s.saw_event = true;
             },
diff --git a/src/host_io.zig b/src/host_io.zig
index 6009c00f..820cb2b6 100644
--- a/src/host_io.zig
+++ b/src/host_io.zig
@@ -949,6 +949,9 @@ test "the child environment replaces the launcher's terminal identity exactly on
 
 extern "c" fn unsetenv(name: [*:0]const u8) c_int;
 
+/// The longest line a command pane runs (exec.zig refuses a longer one).
+pub const exec_command_max = pardes.exec.command_max;
+
 pub fn forkShell(
     core: ?*pardes.Pardes,
     pane: usize,
@@ -973,9 +976,19 @@ pub fn forkShell(
     };
     var master: c_int = -1;
     var path_buf: [std.fs.max_path_bytes]u8 = undefined;
-    const spawn = Shell.resolve(bin, &path_buf, prompt_rcs);
+    var spawn = Shell.resolve(bin, &path_buf, prompt_rcs);
+    // A command pane's child is the shell running its one line, which has
+    // no prompt to mark (exec.zig runCommand).
+    const one_line = if (core) |c| if (c.panes[pane]) |pn| pn.command else null else null;
+    var command_buf: [exec_command_max + 1]u8 = undefined;
+    if (one_line) |line| {
+        if (line.len > exec_command_max or std.mem.indexOfScalar(u8, line, 0) != null) return error.InvalidCommand;
+        @memcpy(command_buf[0..line.len], line);
+        command_buf[line.len] = 0;
+        spawn.argv = .{ spawn.path, "-c", command_buf[0..line.len :0].ptr, null };
+    }
     var helper_buf: [4096]u8 = undefined;
-    const mounted = if (core) |c| if (c.panes[pane]) |pn| pn.v9fs_on_spawn else false else false;
+    const mounted = one_line == null and if (core) |c| if (c.panes[pane]) |pn| pn.v9fs_on_spawn else false else false;
     const helper: ?[:0]u8 = if (mounted) blk: {
         if (comptime builtin.os.tag != .linux) return error.LinuxRequired;
         if (fs == null) return error.SessionSocketRequired;
@@ -1016,7 +1029,7 @@ pub fn forkShell(
         _exit(127);
     }
     ninep_io.setCloexec(master);
-    if (core) |c| c.acknowledgeShell(pane, std.mem.span(spawn.path), spawn.argv[1] != null);
+    if (core) |c| c.acknowledgeShell(pane, std.mem.span(spawn.path), one_line == null and spawn.argv[1] != null);
     return .{ .file = .{ .handle = master, .flags = .{ .nonblocking = false } }, .pid = pid };
 }
 
@@ -1349,6 +1362,29 @@ pub fn retireShell(pid: libc.pid_t) void {
     thread.detach();
 }
 
+/// A pane's child at its pty's end of file: reaped, and how it exited
+/// (its code, or 128 and the signal that ended it), if it is gone within
+/// `wait_ms`; null if it is still running (a job it left holds nothing
+/// open, but the child itself may be a moment behind its pty), which the
+/// caller then retires as it would any shell.
+pub fn exitStatus(pid: libc.pid_t, wait_ms: u32) ?u8 {
+    if (pid <= 0) return null;
+    var waited: u32 = 0;
+    while (true) : (waited += 2) {
+        var status: c_int = 0;
+        const got = libc.waitpid(pid, &status, libc.W.NOHANG);
+        if (got == pid) {
+            const s: u32 = @bitCast(status);
+            if (libc.W.IFEXITED(s)) return @truncate(libc.W.EXITSTATUS(s));
+            if (libc.W.IFSIGNALED(s)) return @truncate(128 + @as(u32, @intFromEnum(libc.W.TERMSIG(s))));
+            return null;
+        }
+        if (got < 0 or waited >= wait_ms) return null;
+        const ts: libc.timespec = .{ .sec = 0, .nsec = 2 * std.time.ns_per_ms };
+        _ = libc.nanosleep(&ts, null);
+    }
+}
+
 fn reapShell(pid: libc.pid_t, grace_ms: u32) void {
     var waited: u32 = 0;
     while (waited < grace_ms) : (waited += 5) {
@@ -1711,6 +1747,28 @@ test "Kill stops the foreground job, never the shell, and finds none with job co
     try std.testing.expectEqual(@as(libc.pid_t, 0), libc.waitpid(sh.pid, null, libc.W.NOHANG));
 }
 
+test "a command pane's child is its shell running the one line, and its exit status is read at the end" {
+    if (comptime !tty_probe_platform) return error.SkipZigTest;
+    const core = try pardes.Pardes.init(std.testing.allocator, .{ .tty_only = true });
+    defer core.deinit();
+    while (core.nextEffect()) |_| {}
+    const id = core.freeSlot().?;
+    _ = try core.newCommand(id, "", "printf 'said '; exit 7");
+    while (core.nextEffect()) |_| {}
+    const rcs: Shell.PromptFiles = .{};
+    const child = try forkShell(core, id, &rcs, "/bin/sh", "", 24, 80, null);
+    defer _ = libc.close(child.file.handle);
+    var got: [256]u8 = undefined;
+    var n: usize = 0;
+    while (n < got.len) {
+        const r = libc.read(child.file.handle, got[n..].ptr, got.len - n);
+        if (r <= 0) break; // EIO once the child is gone: the pty's end
+        n += @intCast(r);
+    }
+    try std.testing.expect(std.mem.indexOf(u8, got[0..n], "said") != null);
+    try std.testing.expectEqual(@as(?u8, 7), exitStatus(child.pid, 2000));
+}
+
 test "a retired shell that ignores the hangup is killed and reaped, not left a zombie" {
     const pid = libc.fork();
     if (pid == 0) {
diff --git a/src/macos.zig b/src/macos.zig
index 7bfa6c49..97dab9a8 100644
--- a/src/macos.zig
+++ b/src/macos.zig
@@ -1280,8 +1280,14 @@ fn drainInbox(st: *State) bool {
             },
             .eof => |e| {
                 if (st.gens[e.pane] != e.gen) continue;
+                // Reaped here, its status kept, it is no shell to retire.
+                const status = if (st.ptys[e.pane]) |*pt| status: {
+                    const got = host_io.exitStatus(pt.pid, 100);
+                    if (got != null) pt.pid = 0;
+                    break :status got;
+                } else null;
                 reap(st, e.pane);
-                st.core.update(.{ .eof = .{ .pane = e.pane } });
+                st.core.update(.{ .eof = .{ .pane = e.pane, .status = status } });
             },
             .lsp_done => |d| {
                 st.core.update(.{ .lsp_resp = .{ .id = d.id, .rows = d.rows } });
diff --git a/src/ninep/ctl.zig b/src/ninep/ctl.zig
index c1cfa1f6..deb64565 100644
--- a/src/ninep/ctl.zig
+++ b/src/ninep/ctl.zig
@@ -67,7 +67,12 @@ fn run(p: *Pardes, id: usize, exec: bool, text: []const u8) void {
         return noteResult(p, context);
     }
     const before = Serials.snapshot(p);
-    if (exec) _ = pardes.exec.execute(p, id, text) else look.lookAt(p, id, text);
+    // An exec answers the pane it went to: a command pane it reused, or
+    // the terminal it typed into.
+    const went: ?usize = if (exec) pardes.exec.execute(p, id, text) else blk: {
+        look.lookAt(p, id, text);
+        break :blk null;
+    };
     const after = Serials.snapshot(p);
     var created = false;
     for (after.list[0..after.len]) |serial| if (std.mem.indexOfScalar(u32, before.list[0..before.len], serial) == null) {
@@ -75,6 +80,7 @@ fn run(p: *Pardes, id: usize, exec: bool, text: []const u8) void {
         created = true;
     };
     if (created) return;
+    if (went) |dst| if (p.panes[dst]) |pane| return noteResult(p, pane.serial);
     noteResult(p, if (exec) context else (p.panes[p.active] orelse return).serial);
 }
 
diff --git a/src/panes.zig b/src/panes.zig
index 09b93aa3..a7f7f69f 100644
--- a/src/panes.zig
+++ b/src/panes.zig
@@ -102,6 +102,13 @@ pub const Pane = struct {
     /// middle click, a pty/run): its first word, which Kill matches, and
     /// the shell's command count its start (C mark) reaches.
     sent_command: ?struct { word: [64]u8 = undefined, len: u8 = 0, seq: u32 = 0 } = null,
+    /// A command pane (exec.zig runCommand): the line its child runs as
+    /// `$SHELL -c`, owned, where an interactive terminal has null.
+    command: ?[]u8 = null,
+    /// The command's child has exited, and with what status (null: unknown,
+    /// shown `exit ?`).
+    command_done: bool = false,
+    command_status: ?u8 = null,
     /// The revision an Exit or a Restore last warned this pane was modified
     /// at, and which of them: only that word goes ahead on the warning
     /// (builtins.zig warnModified).
diff --git a/src/pardes.zig b/src/pardes.zig
index 9fa747cd..1bb13e3d 100644
--- a/src/pardes.zig
+++ b/src/pardes.zig
@@ -1282,34 +1282,35 @@ test "an unsaved file marker sits between its path and builtins until Save" {
     try std.testing.expect(std.mem.indexOf(u8, output, "/test.txt *") == null);
 }
 
-test "unknown Exec from an image writes to a terminal in the image directory" {
+test "unknown Exec from a document runs as a command pane in its directory, typed into no terminal" {
     const gpa = std.testing.allocator;
     const p = try Pardes.init(gpa, .{});
     defer p.deinit();
     while (p.nextEffect()) |_| {}
     p.acknowledgeShell(0, "/bin/sh", false);
 
+    // A terminal free at a prompt in the same directory is not borrowed.
     p.setCwd(0, "/tmp/pardes-image-dir");
     const image_doc = try p.newDocPane(1);
     image_doc.image = .{ .path = try gpa.dupe(u8, "/tmp/pardes-image-dir/pic.ppm") };
     try std.testing.expectEqualStrings("/tmp/pardes-image-dir", Pardes.paneDir(image_doc));
-    try std.testing.expectEqual(@as(?usize, 0), exec.execute(p, 1, "echo image-fallback"));
+    const dst = exec.execute(p, 1, "echo image-fallback") orelse return error.ExecFoundNowhereToRun;
+    try std.testing.expect(dst != 0 and dst != 1);
+    try std.testing.expectEqualStrings("echo image-fallback", p.panes[dst].?.command.?);
 
-    var sent: [256]u8 = undefined;
-    var sent_len: usize = 0;
+    var spawned = false;
     while (p.nextEffect()) |effect| switch (effect) {
-        .write => |w| {
-            try std.testing.expectEqual(@as(u8, 0), w.pane);
-            try std.testing.expect(w.bytes.slice().len <= sent.len - sent_len);
-            @memcpy(sent[sent_len..][0..w.bytes.slice().len], w.bytes.slice());
-            sent_len += w.bytes.slice().len;
+        .write => return error.TypedIntoATerminal,
+        .spawn => |sp| if (sp.pane == dst) {
+            try std.testing.expectEqualStrings("/tmp/pardes-image-dir", sp.cwd.slice());
+            spawned = true;
         },
-        .spawn => return error.ImageExecSpawnedDespiteMatchingTerminal,
         else => {},
     };
-    try std.testing.expectEqualStrings("echo image-fallback\r", sent[0..sent_len]);
+    try std.testing.expect(spawned);
 }
 
+
 const FakeTtyQuery = struct {
     taken: [MAX_PANES]bool = @splat(false),
     asked: usize = 0,
@@ -1327,7 +1328,7 @@ const FakeTtyQuery = struct {
     }
 };
 
-test "Exec in a terminal whose tty is taken spawns a shell instead of typing at the program" {
+test "Exec in a terminal whose tty is taken runs as a command pane instead of typing at the program" {
     const gpa = std.testing.allocator;
     const p = try Pardes.init(gpa, .{});
     defer p.deinit();
@@ -1340,42 +1341,85 @@ test "Exec in a terminal whose tty is taken spawns a shell instead of typing at
     host.install(p);
     host.taken[0] = true;
     const dst = exec.execute(p, 0, "echo taken-fallback") orelse return error.ExecFoundNowhereToRun;
-    // somewhere ELSE — and still without moving focus, which is execute's
+    // somewhere ELSE -- and still without moving focus, which is execute's
     // contract and the whole difference between it and a look
     try std.testing.expect(dst != 0);
     try std.testing.expectEqual(@as(usize, 0), p.active);
-
-    var spawned: ?Effect = null;
-    var sent: [256]u8 = undefined;
-    var sent_len: usize = 0;
+    try std.testing.expectEqualStrings("echo taken-fallback", p.panes[dst].?.command.?);
+    var spawned = false;
     while (p.nextEffect()) |effect| switch (effect) {
-        .write => |w| {
-            if (w.pane == 0) return error.WroteACommandLineIntoTheProgramOnTheTty;
-            try std.testing.expectEqual(@as(u8, @intCast(dst)), w.pane);
-            try std.testing.expect(w.bytes.slice().len <= sent.len - sent_len);
-            @memcpy(sent[sent_len..][0..w.bytes.slice().len], w.bytes.slice());
-            sent_len += w.bytes.slice().len;
+        .write => return error.WroteACommandLineIntoATerminal,
+        .spawn => |sp| if (sp.pane == dst) {
+            // ...in the directory the command was about, the taken pane's own
+            try std.testing.expectEqualStrings("/tmp/pardes-taken", sp.cwd.slice());
+            spawned = true;
         },
-        .spawn => spawned = effect,
         else => {},
     };
-    const sp = (spawned orelse return error.NoShellForTheOccupiedTerminal).spawn;
-    try std.testing.expectEqual(@as(u8, @intCast(dst)), sp.pane);
-    // ...in the directory the command was about, which is the taken pane's own
-    try std.testing.expectEqualStrings("/tmp/pardes-taken", sp.cwd.slice());
-    try std.testing.expectEqual(@as(usize, 0), sent_len);
-    p.acknowledgeShell(dst, "/bin/sh", false);
-    while (p.nextEffect()) |effect| switch (effect) {
-        .write => |w| {
-            try std.testing.expectEqual(@as(u8, @intCast(dst)), w.pane);
-            @memcpy(sent[sent_len..][0..w.bytes.slice().len], w.bytes.slice());
-            sent_len += w.bytes.slice().len;
-        },
-        else => {},
+    try std.testing.expect(spawned);
+}
+
+test "a command pane shows how its command ended, and the next command there runs below it" {
+    const gpa = std.testing.allocator;
+    const p = try Pardes.init(gpa, .{});
+    defer p.deinit();
+    while (p.nextEffect()) |_| {}
+    p.setCwd(0, "/tmp/pardes-cmd");
+    const doc = try p.newDocPane(1);
+    doc.image = .{ .path = try gpa.dupe(u8, "/tmp/pardes-cmd/pic.ppm") };
+
+    const dst = exec.execute(p, 1, "make -j8") orelse return error.NoCommandPane;
+    while (p.nextEffect()) |_| {}
+    const pane = p.panes[dst].?;
+    var frame = std.heap.ArenaAllocator.init(gpa);
+    defer frame.deinit();
+    try std.testing.expect(std.mem.endsWith(u8, try tagline.tagPrefix(p, pane), "(make -j8) running"));
+    // Running, a second command goes to a pane of its own.
+    const other = exec.execute(p, 1, "ls") orelse return error.NoCommandPane;
+    try std.testing.expect(other != dst);
+    while (p.nextEffect()) |_| {}
+    p.update(.{ .output = .{ .pane = @intCast(dst), .bytes = "compiled\r\n" } });
+    p.update(.{ .eof = .{ .pane = @intCast(dst), .status = 2 } });
+    try std.testing.expect(p.panes[dst] == pane);
+    try std.testing.expect(pane.command_done);
+    try std.testing.expect(std.mem.endsWith(u8, try tagline.tagPrefix(p, pane), "(make -j8) exit 2"));
+    // Kill leaves a finished one be.
+    try std.testing.expect(p.executeBuiltinLine(0, "Kill make"));
+    while (p.nextEffect()) |effect| if (effect == .signal_pty and effect.signal_pty.pane == dst) return error.SignalledAFinishedCommand;
+    // Done, the directory's next command runs there, below what it showed.
+    try std.testing.expectEqual(@as(?usize, dst), exec.execute(p, 1, "make test"));
+    var respawned = false;
+    while (p.nextEffect()) |effect| if (effect == .spawn and effect.spawn.pane == dst) {
+        respawned = true;
+    };
+    try std.testing.expect(respawned);
+    const body = try panes.Terminal.screenTextAlloc(pane, gpa);
+    defer gpa.free(body);
+    const said = std.mem.indexOf(u8, body, "compiled") orelse return error.OutputLost;
+    const ended = std.mem.indexOf(u8, body, "exit 2") orelse return error.ExitLost;
+    const next = std.mem.indexOf(u8, body, "% make test") orelse return error.NoSeparator;
+    try std.testing.expect(said < ended and ended < next);
+    try std.testing.expect(std.mem.endsWith(u8, try tagline.tagPrefix(p, pane), "(make test) running"));
+    // Kill stops a running one: its whole process group, SIGTERM.
+    try std.testing.expect(p.executeBuiltinLine(0, "Kill make"));
+    var signalled = false;
+    while (p.nextEffect()) |effect| if (effect == .signal_pty and effect.signal_pty.pane == dst) {
+        try std.testing.expectEqual(PtySignal.term, effect.signal_pty.sig);
+        signalled = true;
     };
-    try std.testing.expectEqualStrings("echo taken-fallback\r", sent[0..sent_len]);
+    try std.testing.expect(signalled);
+    // The log says what ran and how it ended.
+    const log = try ctlfs.events.freezeLog(p);
+    defer gpa.free(log.bytes);
+    var want: [64]u8 = undefined;
+    try std.testing.expect(std.mem.indexOf(u8, log.bytes, try std.fmt.bufPrint(&want, "run {d} make\n", .{pane.serial})) != null);
+    try std.testing.expect(std.mem.indexOf(u8, log.bytes, try std.fmt.bufPrint(&want, "exit {d} 2\n", .{pane.serial})) != null);
+    // A command line longer than a command pane takes is refused.
+    const long = "x" ** (exec.command_max + 1);
+    try std.testing.expectEqual(@as(?usize, null), exec.execute(p, 1, long));
 }
 
+
 test "image dump restores source bytes renderer choices and exact custom tail" {
     const gpa = std.testing.allocator;
     const p = try Pardes.init(gpa, .{ .tty_only = true });
@@ -1428,50 +1472,6 @@ test "image dump restores source bytes renderer choices and exact custom tail" {
     try std.testing.expectEqualStrings(" Keep Del", redump.panes[0].tag_tail.?);
 }
 
-test "Exec from a document pane skips an occupied terminal in its directory and spawns" {
-    const gpa = std.testing.allocator;
-    const p = try Pardes.init(gpa, .{});
-    defer p.deinit();
-    while (p.nextEffect()) |_| {}
-
-    p.setCwd(0, "/tmp/pardes-image-dir");
-    const image_doc = try p.newDocPane(1);
-    image_doc.image = .{ .path = try gpa.dupe(u8, "/tmp/pardes-image-dir/pic.ppm") };
-    var host: FakeTtyQuery = .{};
-    host.install(p);
-    host.taken[0] = true;
-
-    const dst = exec.execute(p, 1, "echo image-fallback") orelse return error.ExecFoundNowhereToRun;
-    try std.testing.expect(dst != 0 and dst != 1);
-
-    var spawned: ?Effect = null;
-    var sent: [256]u8 = undefined;
-    var sent_len: usize = 0;
-    while (p.nextEffect()) |effect| switch (effect) {
-        .write => |w| {
-            if (w.pane == 0) return error.WroteACommandLineIntoTheProgramOnTheTty;
-            try std.testing.expectEqual(@as(u8, @intCast(dst)), w.pane);
-            try std.testing.expect(w.bytes.slice().len <= sent.len - sent_len);
-            @memcpy(sent[sent_len..][0..w.bytes.slice().len], w.bytes.slice());
-            sent_len += w.bytes.slice().len;
-        },
-        .spawn => spawned = effect,
-        else => {},
-    };
-    const sp = (spawned orelse return error.NoShellForTheOccupiedTerminal).spawn;
-    try std.testing.expectEqualStrings("/tmp/pardes-image-dir", sp.cwd.slice());
-    try std.testing.expectEqual(@as(usize, 0), sent_len);
-    p.acknowledgeShell(dst, "/bin/sh", false);
-    while (p.nextEffect()) |effect| switch (effect) {
-        .write => |w| {
-            try std.testing.expectEqual(@as(u8, @intCast(dst)), w.pane);
-            @memcpy(sent[sent_len..][0..w.bytes.slice().len], w.bytes.slice());
-            sent_len += w.bytes.slice().len;
-        },
-        else => {},
-    };
-    try std.testing.expectEqualStrings("echo image-fallback\r", sent[0..sent_len]);
-}
 
 test "a Look on a directory does not type ls into an occupied terminal" {
     const gpa = std.testing.allocator;
@@ -1574,11 +1574,13 @@ test "the host is asked about a tty only where a command line is about to go" {
     while (p.nextEffect()) |_| {}
     try std.testing.expectEqual(@as(usize, 1), host.asked);
 
+    // ...and a taken one is asked once too: the line then runs as a command
+    // pane, with no other terminal to ask about.
     host.taken[0] = true;
     host.asked = 0;
     _ = exec.execute(p, 0, "echo lazy-again");
     while (p.nextEffect()) |_| {}
-    try std.testing.expectEqual(@as(usize, 2), host.asked);
+    try std.testing.expectEqual(@as(usize, 1), host.asked);
 }
 
 test "New opens an empty scratch below the caller, inheriting its directory" {
@@ -3081,7 +3083,9 @@ pub const Event = union(enum) {
         row_metrics: ?RowMetrics = null,
     },
     output: struct { pane: u8, bytes: []const u8 },
-    eof: struct { pane: u8 },
+    /// The pane's child hung up its pty; `status` is how it exited, when
+    /// the host could reap it at once (a command pane shows it).
+    eof: struct { pane: u8, status: ?u8 = null },
     lsp_resp: struct { id: u32, rows: ?[]const u8 },
     pipe_resp: struct {
         id: u32,
@@ -4183,6 +4187,7 @@ pub const Pardes = struct {
         p.shell_rows.dropPane(pane);
         for (0..pane.pointer_selections.len) |slot| pane.clearPointerSelection(slot);
         panes.Terminal.deinitPendingCommand(pane);
+        if (pane.command) |line| p.gpa.free(line);
         if (pane.image) |*iv| {
             iv.deinit(p.image_gpa);
         }
@@ -4228,6 +4233,25 @@ pub const Pardes = struct {
         return pane;
     }
 
+    /// A command pane: a terminal whose child is `$SHELL -c line` rather
+    /// than an interactive shell, left showing its output and `exit N` when
+    /// it is done (exec.zig runCommand).
+    pub fn newCommand(p: *Pardes, id: usize, cwd: []const u8, line: []const u8) !*Pane {
+        std.debug.assert(p.panes[id] == null);
+        if (cwd.len > effect_path_cap) return error.PathTooLong;
+        const owned = try p.gpa.dupe(u8, line);
+        errdefer p.gpa.free(owned);
+        const pane = try panes.Terminal.create(p.gpa, p.screen_w, p.screen_h);
+        pane.command = owned;
+        pane.body.mode = .tty;
+        // Its directory is the one it was run for, and says which of the
+        // directory's commands reuse it; the child's own cd does not move it.
+        pane.setOwnedCwd(cwd) catch {};
+        p.installPane(id, pane);
+        p.emit(.{ .spawn = .{ .pane = @intCast(id), .cwd = .from(cwd) } });
+        return pane;
+    }
+
     pub fn newDocPane(p: *Pardes, id: usize) !*Pane {
         std.debug.assert(p.panes[id] == null);
         const pane = try panes.Terminal.createDoc(p.gpa, p.screen_w, p.screen_h);
@@ -4324,6 +4348,8 @@ pub const Pardes = struct {
     /// changes it observes, e.g. via /proc/<pid>/cwd before each frame).
     pub fn setCwd(p: *Pardes, id: usize, cwd: []const u8) void {
         const pane = p.panes[id] orelse return;
+        // A command pane stays the directory's it was run for (newCommand).
+        if (pane.command != null) return;
         const cur = switch (pane.cwd) {
             .owned => |dir| dir,
             else => "",
@@ -4777,8 +4803,10 @@ pub const Pardes = struct {
                 panes.Terminal.feedOutput(p, pane, o.bytes);
                 ctlfs.pty.noteMarks(p, o.pane, pane);
             },
-            .eof => |e| p.removePane(e.pane, null) catch |err| {
-                if (p.panes[e.pane]) |pane| pane.body.mode = .normal;
+            .eof => |e| if (p.panes[e.pane]) |pane| if (pane.command != null) {
+                exec.commandDone(p, e.pane, e.status);
+            } else p.removePane(e.pane, null) catch |err| {
+                pane.body.mode = .normal;
                 p.reportError(e.pane, "terminal exited; Del retries close", err);
             },
             .lsp_resp => |r| p.lspResponse(r.id, r.rows),
diff --git a/src/tagline.zig b/src/tagline.zig
index 92c18510..8b214fa6 100644
--- a/src/tagline.zig
+++ b/src/tagline.zig
@@ -21,6 +21,7 @@ pub const file_pane_tail = " " ++ config.file_pane_builtins_str;
 pub const context_pane_tail = file_pane_tail ++ " TreeContext";
 pub const locations_pane_tail = file_pane_tail ++ " LocationsConfig";
 pub const terminal_pane_tail = " " ++ config.terminal_pane_builtins_str;
+pub const command_pane_tail = " " ++ config.command_pane_builtins_str;
 const dirty_marker = " *";
 pub const legacy_pane_tail = " Del";
 pub const legacy_file_pane_tail = " Save Del";
@@ -109,6 +110,14 @@ pub fn pathPrefix(arena: std.mem.Allocator, pane: *Pane) ![]const u8 {
     if (comptime pdf_enabled) if (pane.pdf) |pv|
         return std.fmt.allocPrint(arena, "{s} [{d}/{d}]", .{ pv.path, pv.page + 1, pv.page_count });
     if (pane.image) |*state| return panes.Image.tagPrefix(arena, state);
+    // A command pane: its directory, the line it runs, and how that went.
+    if (pane.command) |line| {
+        const shown = line[0..@min(line.len, 48)];
+        const more = if (shown.len < line.len) "..." else "";
+        if (!pane.command_done) return std.fmt.allocPrint(arena, "{s} ({s}{s}) running", .{ pane.cwdSlice(), shown, more });
+        if (pane.command_status) |n| return std.fmt.allocPrint(arena, "{s} ({s}{s}) exit {d}", .{ pane.cwdSlice(), shown, more, n });
+        return std.fmt.allocPrint(arena, "{s} ({s}{s}) exit ?", .{ pane.cwdSlice(), shown, more });
+    }
     if (pane.file) |f| {
         const name = if (pane.prompt == .name) pane.input.own orelse f.path else f.path;
         if (panes.Output.fileTraits(f.output).saves and f.revision != f.saved_revision)
@@ -148,6 +157,7 @@ pub fn defaultTail(pane: *const Pane) []const u8 {
         if (panes.Output.usesLocationsConfig(out.from)) return locations_pane_tail;
     if (panes.File.supportsContext(pane)) return context_pane_tail;
     if (pane.file != null) return file_pane_tail;
+    if (pane.command != null) return command_pane_tail;
     if (pane.isTerminal()) return terminal_pane_tail;
     return pane_tail;
 }
diff --git a/src/tty/tty.zig b/src/tty/tty.zig
index 4c1e2db7..490958ee 100644
--- a/src/tty/tty.zig
+++ b/src/tty/tty.zig
@@ -1006,13 +1006,15 @@ const Shell = struct {
                 return true;
             },
             .pty_eof => |e| if (s.gens[e.id] == e.gen) {
+                var status: ?u8 = null;
                 if (s.ptys[e.id]) |*pt| {
                     pt.reader.await(s.io) catch {}; // reader just finished; join it or its future leaks
                     _ = libc.close(pt.file.handle);
-                    host_io.retireShell(pt.pid);
+                    status = host_io.exitStatus(pt.pid, 100);
+                    if (status == null) host_io.retireShell(pt.pid);
                     s.ptys[e.id] = null;
                 }
-                core.update(.{ .eof = .{ .pane = @intCast(e.id) } });
+                core.update(.{ .eof = .{ .pane = @intCast(e.id), .status = status } });
             },
             .key_press => |key| if (s.in_paste) {
                 const bytes = pasteBytes(key);