pardes NEWFILE in a pane opens a pane named it in the session, as acme's B does, and a start with no terminal says so

A name that did not exist yet failed resolveOs, so the launch fell through to starting an editor of its own, which on a pty with no controlling terminal (a detached session's) ended in a NoDevice error trace. A new name's directory is now resolved and the name kept: the launch reads pane/new and writes that path to the pane's name, so Save creates the file, and --wait waits on that pane (the git commit case). A standalone start whose /dev/tty will not open prints why and exits 1. fs.py covers both; the known-wrong line in docs/divergences.md goes.

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

3 files changed, 65 insertions, 7 deletions

diff --git a/docs/divergences.md b/docs/divergences.md
index 17179029..21e5167e 100644
--- a/docs/divergences.md
+++ b/docs/divergences.md
@@ -18,7 +18,5 @@ moving a bookmark does not quietly orphan work or hide a failure.
 
 ## Known wrong on `main`
 
-- `pardes FILE` in a pane forwards only a FILE that exists; a new file name
-  starts a separate editor instead of opening a pane in the session.
 - `Dump` fails `no such directory` when the default `DumpDir`'s parent
   (`$XDG_DATA_HOME`, or `~/.local/share`) does not exist.
diff --git a/src/main.zig b/src/main.zig
index ec2472d7..ab6f1527 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -408,10 +408,30 @@ fn nativeMain(init: std.process.Init) !void {
         if (std.mem.indexOfAny(u8, word, "\r\n") != null) break :forwarding;
         const target = @import("look.zig").parsePathLine(word);
         var realbuf: [4096]u8 = undefined;
-        const path = if (pardes.filesystem.isVirtual(target.path)) target.path else (pardes.filesystem.resolveOs(target.path, &realbuf) orelse break :forwarding).path;
-        var command_buf: [8192]u8 = undefined;
-        const command = std.fmt.bufPrint(&command_buf, "{s}{s}\n", .{ path, word[target.path.len..] }) catch break :forwarding;
-        ninep_io.Client.write(arena, parent.dial, look, command) catch break :forwarding;
+        var newbuf: [4096]u8 = undefined;
+        const found_path: ?[]const u8 = if (pardes.filesystem.isVirtual(target.path)) target.path else if (pardes.filesystem.resolveOs(target.path, &realbuf)) |r| r.path else null;
+        const path = found_path orelse named: {
+            // A name not there yet, as acme's B takes one: its directory
+            // resolved and the name kept, a pane made for it that Save
+            // creates the file from.
+            const base = std.fs.path.basename(target.path);
+            if (base.len == 0 or std.mem.eql(u8, base, ".") or std.mem.eql(u8, base, "..")) break :forwarding;
+            const dir = pardes.filesystem.resolveOs(std.fs.path.dirname(target.path) orelse ".", &realbuf) orelse break :forwarding;
+            break :named std.fmt.bufPrint(&newbuf, "{s}/{s}", .{ std.mem.trimEnd(u8, dir.path, "/"), base }) catch break :forwarding;
+        };
+        if (found_path != null) {
+            var command_buf: [8192]u8 = undefined;
+            const command = std.fmt.bufPrint(&command_buf, "{s}{s}\n", .{ path, word[target.path.len..] }) catch break :forwarding;
+            ninep_io.Client.write(arena, parent.dial, look, command) catch break :forwarding;
+        } else {
+            const made = ninep_io.Client.read(arena, parent.dial, "/pane/new", "/pane/new") catch break :forwarding;
+            const serial = std.fmt.parseInt(u32, std.mem.trim(u8, made, " \n"), 10) catch break :forwarding;
+            var name_buf: [64]u8 = undefined;
+            const name = try std.fmt.bufPrint(&name_buf, "/pane/{d}/name", .{serial});
+            var line_buf: [4200]u8 = undefined;
+            const line = std.fmt.bufPrint(&line_buf, "{s}\n", .{path}) catch break :forwarding;
+            ninep_io.Client.write(arena, parent.dial, name, line) catch break :forwarding;
+        }
         if (wait) waitForDel(init.io, arena, parent.dial, path);
         return;
     }
@@ -468,7 +488,15 @@ fn nativeMain(init: std.process.Init) !void {
         std.process.exit(1);
     }
     switch (pardes.platform) {
-        .tty => try @import("tty/tty.zig").run(init, opts, attach),
+        .tty => @import("tty/tty.zig").run(init, opts, attach) catch |err| switch (err) {
+            // No controlling terminal (a detached pty, a daemon): said, not
+            // an error trace.
+            error.NoDevice => {
+                std.Io.File.stderr().writeStreamingAll(init.io, "pardes: no terminal to draw on: /dev/tty will not open; run it in a terminal, or --detach\n") catch {};
+                std.process.exit(1);
+            },
+            else => return err,
+        },
         .gui => try @import("gui/gui.zig").run(init, opts, attach),
         .web, .macos, .esp32p4 => unreachable,
     }
diff --git a/test/fs.py b/test/fs.py
index db10f32d..15f4eb8b 100644
--- a/test/fs.py
+++ b/test/fs.py
@@ -1261,10 +1261,42 @@ def test(binary, quic=False):
             assert time.monotonic() - deleted < .05, time.monotonic() - deleted
             assert second.wait(timeout=5) == 0
             assert edited.read_bytes() == b'edited\n'
+            # A name not there yet opens a pane named it, as acme's B does,
+            # and Save creates it: git's and fish's temporary files are.
+            fresh = root / 'wait new.txt'
+            before = serials()
+            made = subprocess.Popen([binary, '--wait', fresh.name], cwd=root, env=env,
+                                    stdout=subprocess.DEVNULL, stderr=subprocess.PIPE)
+            deadline = time.monotonic() + 3
+            while not serials() - before:
+                assert made.poll() is None, made.stderr.read()
+                assert time.monotonic() < deadline, 'a new name opened no pane'
+                time.sleep(.01)
+            named, = serials() - before
+            assert str(fresh).encode() in client.read('/index')
+            client.write(f'/pane/{named}/body', b'new\n')
+            execute(client, named, 'Save')
+            client.remove(f'/pane/{named}')
+            assert made.wait(timeout=5) == 0
+            assert fresh.read_bytes() == b'new\n'
             orphan = launch('--wait')
             assert orphan.poll() is None
         assert orphan.wait(timeout=5) == 1
 
+        # A launch with no terminal to draw on (a pty that is no one's
+        # controlling terminal) says so and exits 1, no error trace.
+        master, slave = os.openpty()
+        try:
+            env = {k: v for k, v in os.environ.items() if not k.startswith('PARDES_')}
+            env.update(HOME=str(root), XDG_RUNTIME_DIR=str(root), TERM='xterm-256color')
+            result = subprocess.run([binary, '--tty', 'x.txt'], cwd=root, env=env, stdin=slave, stdout=slave,
+                                    stderr=subprocess.PIPE, start_new_session=True, timeout=10)
+        finally:
+            os.close(master)
+            os.close(slave)
+        assert result.returncode == 1, result
+        assert b'pardes: no terminal to draw on' in result.stderr and b'.zig:' not in result.stderr, result.stderr
+
         for tty in [False, True]:
             name = 'lsp-tty' if tty else 'lsp-detached'
             with session(binary, root, name, tty=tty) as (client, _):