Nothing about a pane is logged before its new, and the boot terminal's new carries the session directory, not / and a rename

A pane named in the update that made it (Config's init file, a look
renamed on open) logged `rename N <name>` before `new N`, so a follower met
a serial it had never seen. The boot shell, started with no directory, was
announced as `new 1 /` and renamed once its shell spoke. Now noteLog drops
the rename of a pane not yet announced, since its new carries the name, and
announces a pane first for any other record about it. A terminal whose shell
has not said where it is is named by the session's directory, where it was
started, and the shell saying so is no rename.

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

1 files changed, 15 insertions, 13 deletions

diff --git a/src/ninep/pane.zig b/src/ninep/pane.zig
index eb317655..30530c3b 100644
--- a/src/ninep/pane.zig
+++ b/src/ninep/pane.zig
@@ -134,12 +134,14 @@ pub fn dirtyOf(pane: *const Pane) bool {
 }
 
 /// The pane's name: its file, its document, or a terminal's directory.
-pub fn nameOf(pane: *const Pane) []const u8 {
+pub fn nameOf(p: *Pardes, pane: *const Pane) []const u8 {
     if (pane.file) |*f| return f.path;
     if (pane.pdfPath()) |path| return path;
     if (pane.image) |state| return state.path;
     const cwd = pane.cwdSlice();
-    return if (cwd.len > 0) cwd else "/";
+    // A shell given no directory was started in the session's, and is
+    // named by it until it says where it is (a `new` then, not a rename).
+    return if (cwd.len > 0) cwd else p.sessionDir();
 }
 
 pub fn kindOf(pane: *const Pane) []const u8 {
@@ -333,7 +335,7 @@ pub fn fileSize(p: *Pardes, id: usize, f: PaneFile) u64 {
         .body => if (pane.file == null and pane.isTerminal()) panes.terminal.screenTextLen(pane) else if (pdfText(p, pane)) |t| t.len else bodyOf(pane).len,
         .data, .xdata => bodyOf(pane).len,
         .tag => tagOf(p, pane).len,
-        .name => nameOf(pane).len + 1,
+        .name => nameOf(p, pane).len + 1,
         .ctl => ctl: {
             var buf: [ctl.pane_text_cap]u8 = undefined;
             break :ctl ctl.paneText(p, pane, &buf).len;
@@ -380,7 +382,7 @@ pub fn indexLen(p: *Pardes) u64 {
         // unreachable: a u32 serial is at most 10 digits
         n += (std.fmt.bufPrint(&digits, "{d}", .{serial}) catch unreachable).len;
         var name_buf: [4 * 4096]u8 = undefined;
-        n += 1 + kindOf(pane).len + 3 + events.shown(nameOf(pane), &name_buf).len + 1;
+        n += 1 + kindOf(pane).len + 3 + events.shown(nameOf(p, pane), &name_buf).len + 1;
         // unreachable: a column index is under 16 digits
         n += 1 + (std.fmt.bufPrint(&digits, "{d}", .{columnOf(p, p.paneBySerial(serial).?)}) catch unreachable).len;
     }
@@ -394,7 +396,7 @@ pub fn read(p: *Pardes, req: Req, id: usize, pane: *Pane, file: PaneFile) Reply
     return switch (file) {
         .name => name: {
             const out = p.fs.stage(p.gpa);
-            out.appendSlice(p.gpa, nameOf(pane)) catch {};
+            out.appendSlice(p.gpa, nameOf(p, pane)) catch {};
             out.append(p.gpa, '\n') catch {};
             break :name tree.stagedReply(p, req);
         },
@@ -1016,7 +1018,7 @@ test "index lists serial kind dirty flag and name and stat reports its length" {
     try testing.expectEqual(@as(u64, both.bytes.len), indexLen(p));
     var expected: [4200]u8 = undefined;
     const made = p.panes[p.paneBySerial(serial).?].?;
-    try testing.expect(std.mem.endsWith(u8, both.bytes, try std.fmt.bufPrint(&expected, "\n{d} text 0 {s} {d}\n", .{ serial, nameOf(made), columnOf(p, p.paneBySerial(serial).?) })));
+    try testing.expect(std.mem.endsWith(u8, both.bytes, try std.fmt.bufPrint(&expected, "\n{d} text 0 {s} {d}\n", .{ serial, nameOf(p, made), columnOf(p, p.paneBySerial(serial).?) })));
 }
 
 test "a terminal is listed as term with its directory as name" {
@@ -1353,13 +1355,13 @@ test "a write of two lines to name is refused EINVAL, on a held open or not" {
     const h = call(p, .{ .tag = 1, .op = .open, .node = node, .omode = 1 }).reply.handle;
     try testing.expectEqual(E.INVAL, call(p, .{ .tag = 2, .op = .write, .node = node, .handle = h, .data = "/tmp/a\n/tmp/b\n" }).errno());
     _ = call(p, .{ .tag = 3, .op = .release, .node = node, .handle = h, .opened = true });
-    try testing.expectEqualStrings("/test.txt", nameOf(p.panes[p.paneBySerial(serial).?].?));
+    try testing.expectEqualStrings("/test.txt", nameOf(p, p.panes[p.paneBySerial(serial).?].?));
     // Line by line, as bash writes it: the second line is refused.
     const h2 = call(p, .{ .tag = 1, .op = .open, .node = node, .omode = 1 }).reply.handle;
     try testing.expectEqual(Status.ok, call(p, .{ .tag = 2, .op = .write, .node = node, .handle = h2, .data = "/tmp/pardes-a\n" }).reply.status);
     try testing.expectEqual(E.INVAL, call(p, .{ .tag = 2, .op = .write, .node = node, .handle = h2, .data = "/tmp/pardes-b\n" }).errno());
     _ = call(p, .{ .tag = 3, .op = .release, .node = node, .handle = h2, .opened = true });
-    try testing.expectEqualStrings("/tmp/pardes-a", nameOf(p.panes[p.paneBySerial(serial).?].?));
+    try testing.expectEqualStrings("/tmp/pardes-a", nameOf(p, p.panes[p.paneBySerial(serial).?].?));
 }
 
 test "a name cut across writes is one name, applied once at its newline or its close" {
@@ -1373,16 +1375,16 @@ test "a name cut across writes is one name, applied once at its newline or its c
     p.fs.write_room = "/tmp/pardes-na".len;
     _ = call(p, .{ .tag = 2, .op = .write, .node = node, .handle = h, .data = "/tmp/pardes-na" });
     p.fs.write_room = 0;
-    try testing.expectEqualStrings("/test.txt", nameOf(p.panes[p.paneBySerial(serial).?].?));
+    try testing.expectEqualStrings("/test.txt", nameOf(p, p.panes[p.paneBySerial(serial).?].?));
     _ = call(p, .{ .tag = 2, .op = .write, .node = node, .handle = h, .data = "me.txt\n" });
-    try testing.expectEqualStrings("/tmp/pardes-name.txt", nameOf(p.panes[p.paneBySerial(serial).?].?));
+    try testing.expectEqualStrings("/tmp/pardes-name.txt", nameOf(p, p.panes[p.paneBySerial(serial).?].?));
     _ = call(p, .{ .tag = 3, .op = .release, .node = node, .handle = h, .opened = true });
     // No newline, the whole write: applied at once, on its own open.
     const h3 = call(p, .{ .tag = 1, .op = .open, .node = node, .omode = 1 }).reply.handle;
     _ = call(p, .{ .tag = 2, .op = .write, .node = node, .handle = h3, .data = "/tmp/pardes-closed.txt" });
-    try testing.expectEqualStrings("/tmp/pardes-closed.txt", nameOf(p.panes[p.paneBySerial(serial).?].?));
+    try testing.expectEqualStrings("/tmp/pardes-closed.txt", nameOf(p, p.panes[p.paneBySerial(serial).?].?));
     _ = call(p, .{ .tag = 3, .op = .release, .node = node, .handle = h3, .opened = true });
-    try testing.expectEqualStrings("/tmp/pardes-closed.txt", nameOf(p.panes[p.paneBySerial(serial).?].?));
+    try testing.expectEqualStrings("/tmp/pardes-closed.txt", nameOf(p, p.panes[p.paneBySerial(serial).?].?));
 }
 
 test "a replace through data, truncate then write, is one undo step" {
@@ -1469,7 +1471,7 @@ test "name reads the file name and writing it promotes a scratch without touchin
     const name = Node.of(serial, .name);
     const body = Node.of(serial, .body);
     var scratch_name: [4200]u8 = undefined;
-    const scratch_line = try std.fmt.bufPrint(&scratch_name, "{s}\n", .{nameOf(pane)});
+    const scratch_line = try std.fmt.bufPrint(&scratch_name, "{s}\n", .{nameOf(p, pane)});
     try testing.expectEqualStrings(scratch_line, rd(p, name, 0, 4096).bytes);
     try testing.expectEqual(@as(u64, scratch_line.len), call(p, .{ .tag = 1, .op = .getattr, .node = name }).reply.attr.size);
     _ = wr(p, body, "scratch ");