Plan 9 idiom for the control filesystem, and the regressions a624a56 left

The 9P tree stops being a command language wearing a filesystem. /new
created a pane as a side effect of a *read*; it is now Tcreate in /pane,
with Tremove to close, which cloud9's engine has always supported and the
editor never declared: tree.zig now says
`features = .{ .create = true, .remove = true }`. Eleven pane ctl verbs
become files that can be read as well as written -- dot, limit, dirty,
mark, scroll, look, exec -- leaving ctl with `get`, the one verb no file
would say better. Root /ctl splits into a read-only /status and the
/look and /exec files whose write IS the click. stat carries real sizes
where it used to answer 0, and qid versions track a pane's revision, so a
client can poll for change without re-reading the body.

Commit a624a56 moved raw-tty keys to an early-return branch that knew only
Ctrl-B and bare Escape, and in the same edit deleted the paste branch below
it. That cost Shift-Escape (the unconditional way out of tty mode) and both
paste chords: Ctrl-V and Ctrl-Shift-V reached the child as keystrokes, so an
agent CLI running in a pane took Ctrl-V for its image-paste binding and
answered "No image found in clipboard". Both are restored, with tests.

Nested detection was not subtly broken but deleted: 60367d8 removed
nested.zig's process-ancestry walk and left "am I inside pardes" derived from
PARDES_FORWARD_LOOK, which read "0" both for --nested and for "the listener
did not come up". PARDES_PID now answers that question on its own, checked
with kill(pid, 0); PARDES_9P and PARDES_PANE answer how to reach it; the flag
is gone. The posted-9P registry also self-heals now -- a session that aborts
cannot unlink its own socket, so posting sweeps entries whose target refuses
a connection, symlinks only and on a definite ECONNREFUSED only.

Elsewhere: tty scrolling is sticky-bottom, following new output only from
the last row, with typing and entering raw mode snapping back to live; the
boot layouts are a Boot enum instead of a chain of ifs, and the bare tty
startup (Boot.tty, which main.zig names) opens an empty text pane under the
shell while tests keep Boot.tty_shell; builtins announce themselves on the
message row under a Verbose setting that is on by default; Config prints
each setting the way you would type it back, so WindowOpacity 70 rather than
"WindowOpacity: 70%"; LocationsConfig opens its window only when called bare;
every tagline puts the word that closes the thing last, and a column now
outlives its panes -- closing the last one leaves an empty pane, and only
Delcol, newly on the column tagline, takes the column away.

Co-Authored-By: Claude Opus 5 (1M context) <[email protected]>

1 files changed, 31 insertions, 0 deletions

diff --git a/src/tty/tty.zig b/src/tty/tty.zig
index 23b7c09b..a1917ba9 100644
--- a/src/tty/tty.zig
+++ b/src/tty/tty.zig
@@ -71,6 +71,21 @@ fn inputReader(loop: *Loop, tty: anytype, cache: *vaxis.GraphemeCache) void {
     loop.postEvent(.quit) catch {};
 }
 
+/// How long a lone ESC waits for the rest of a sequence before it counts as
+/// the Escape key. Long enough for the remainder of a real sequence to arrive
+/// even over a slow link, short enough that nobody sees the delay.
+const escape_hold_ms = 25;
+
+/// Is there more input right behind what we have already read? Only a real
+/// terminal has an fd to ask; the test readers hand their parts over whole, so
+/// for them the answer is always no.
+fn morePending(tty: anytype) bool {
+    const Reader = @typeInfo(@TypeOf(tty)).pointer.child;
+    if (!@hasField(Reader, "fd") or @FieldType(Reader, "fd") != std.Io.File) return false;
+    var fds = [_]std.posix.pollfd{.{ .fd = tty.fd.handle, .events = std.posix.POLL.IN, .revents = 0 }};
+    return (std.posix.poll(&fds, escape_hold_ms) catch return false) > 0;
+}
+
 fn readInput(loop: *Loop, tty: anytype, cache: *vaxis.GraphemeCache) !void {
     try loop.postEvent(.{ .winsize = try tty.getWinsize() });
     var parser: vaxis.Parser = .{};
@@ -101,6 +116,22 @@ fn readInput(loop: *Loop, tty: anytype, cache: *vaxis.GraphemeCache) !void {
         }
         carried = end - consumed;
         std.mem.copyForwards(u8, buf[0..carried], buf[consumed..end]);
+        // A lone ESC opens most sequences and is also the Escape key, so the
+        // parser holds it for a remainder that a keypress never sends: the
+        // press would only land when the NEXT key arrived. Wait a beat, and
+        // when nothing follows it was the key. A terminal speaking the kitty
+        // protocol never reaches here — it spells Escape out in full.
+        if (carried == 1 and buf[0] == 0x1b and !morePending(tty)) {
+            carried = 0;
+            try vaxis.loop.handleEventGeneric(
+                loop,
+                loop.vaxis,
+                cache,
+                @TypeOf(Command.value),
+                @as(vaxis.Event, .{ .key_press = .{ .codepoint = vaxis.Key.escape } }),
+                loop.vaxis.opts.system_clipboard_allocator,
+            );
+        }
     }
 }